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

Module normalized.
  (*
  Enum Type_
  {
    const_params := [];
    ty_params := [];
    variants :=
      [
        {
          name := "Bool";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "U8";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "U64";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "U128";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Address";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Signer";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Struct";
          item :=
            StructRecord
              [
                ("address", Ty.path "move_core_types::account_address::AccountAddress");
                ("module", Ty.path "move_core_types::identifier::Identifier");
                ("name", Ty.path "move_core_types::identifier::Identifier");
                ("type_arguments",
                  Ty.apply
                    (Ty.path "alloc::vec::Vec")
                    []
                    [ Ty.path "move_binary_format::normalized::Type"; Ty.path "alloc::alloc::Global"
                    ])
              ];
          discriminant := None;
        };
        {
          name := "Vector";
          item :=
            StructTuple
              [
                Ty.apply
                  (Ty.path "alloc::boxed::Box")
                  []
                  [ Ty.path "move_binary_format::normalized::Type"; Ty.path "alloc::alloc::Global" ]
              ];
          discriminant := None;
        };
        {
          name := "TypeParameter";
          item := StructTuple [ Ty.path "u16" ];
          discriminant := None;
        };
        {
          name := "Reference";
          item :=
            StructTuple
              [
                Ty.apply
                  (Ty.path "alloc::boxed::Box")
                  []
                  [ Ty.path "move_binary_format::normalized::Type"; Ty.path "alloc::alloc::Global" ]
              ];
          discriminant := None;
        };
        {
          name := "MutableReference";
          item :=
            StructTuple
              [
                Ty.apply
                  (Ty.path "alloc::boxed::Box")
                  []
                  [ Ty.path "move_binary_format::normalized::Type"; Ty.path "alloc::alloc::Global" ]
              ];
          discriminant := None;
        };
        {
          name := "U16";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "U32";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "U256";
          item := StructTuple [];
          discriminant := None;
        }
      ];
  }
  *)
  
  Module Impl_core_clone_Clone_for_move_binary_format_normalized_Type.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Type".
    
    (* Clone *)
    Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.read (|
            M.match_operator (|
              self,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::Bool" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::Bool" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U8" |) in
                    M.alloc (| Value.StructTuple "move_binary_format::normalized::Type::U8" [] |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U64" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::U64" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U128" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::U128" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::Address" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::Address" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::Signer" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::Signer" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_record_field (|
                        γ,
                        "move_binary_format::normalized::Type::Struct",
                        "address"
                      |) in
                    let γ1_1 :=
                      M.SubPointer.get_struct_record_field (|
                        γ,
                        "move_binary_format::normalized::Type::Struct",
                        "module"
                      |) in
                    let γ1_2 :=
                      M.SubPointer.get_struct_record_field (|
                        γ,
                        "move_binary_format::normalized::Type::Struct",
                        "name"
                      |) in
                    let γ1_3 :=
                      M.SubPointer.get_struct_record_field (|
                        γ,
                        "move_binary_format::normalized::Type::Struct",
                        "type_arguments"
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    let __self_1 := M.alloc (| γ1_1 |) in
                    let __self_2 := M.alloc (| γ1_2 |) in
                    let __self_3 := M.alloc (| γ1_3 |) in
                    M.alloc (|
                      Value.StructRecord
                        "move_binary_format::normalized::Type::Struct"
                        [
                          ("address",
                            M.call_closure (|
                              M.get_trait_method (|
                                "core::clone::Clone",
                                Ty.path "move_core_types::account_address::AccountAddress",
                                [],
                                "clone",
                                []
                              |),
                              [ M.read (| __self_0 |) ]
                            |));
                          ("module",
                            M.call_closure (|
                              M.get_trait_method (|
                                "core::clone::Clone",
                                Ty.path "move_core_types::identifier::Identifier",
                                [],
                                "clone",
                                []
                              |),
                              [ M.read (| __self_1 |) ]
                            |));
                          ("name",
                            M.call_closure (|
                              M.get_trait_method (|
                                "core::clone::Clone",
                                Ty.path "move_core_types::identifier::Identifier",
                                [],
                                "clone",
                                []
                              |),
                              [ M.read (| __self_2 |) ]
                            |));
                          ("type_arguments",
                            M.call_closure (|
                              M.get_trait_method (|
                                "core::clone::Clone",
                                Ty.apply
                                  (Ty.path "alloc::vec::Vec")
                                  []
                                  [
                                    Ty.path "move_binary_format::normalized::Type";
                                    Ty.path "alloc::alloc::Global"
                                  ],
                                [],
                                "clone",
                                []
                              |),
                              [ M.read (| __self_3 |) ]
                            |))
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Type::Vector",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Type::Vector"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.apply
                                (Ty.path "alloc::boxed::Box")
                                []
                                [
                                  Ty.path "move_binary_format::normalized::Type";
                                  Ty.path "alloc::alloc::Global"
                                ],
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Type::TypeParameter",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Type::TypeParameter"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "u16",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Type::Reference",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Type::Reference"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.apply
                                (Ty.path "alloc::boxed::Box")
                                []
                                [
                                  Ty.path "move_binary_format::normalized::Type";
                                  Ty.path "alloc::alloc::Global"
                                ],
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Type::MutableReference",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Type::MutableReference"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.apply
                                (Ty.path "alloc::boxed::Box")
                                []
                                [
                                  Ty.path "move_binary_format::normalized::Type";
                                  Ty.path "alloc::alloc::Global"
                                ],
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U16" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::U16" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U32" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::U32" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U256" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::U256" []
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::clone::Clone"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("clone", InstanceField.Method clone) ].
  End Impl_core_clone_Clone_for_move_binary_format_normalized_Type.
  
  Module Impl_core_fmt_Debug_for_move_binary_format_normalized_Type.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Type".
    
    (* Debug *)
    Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; f ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let f := M.alloc (| f |) in
          M.read (|
            M.match_operator (|
              self,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::Bool" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Bool" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U8" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "U8" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U64" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "U64" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U128" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "U128" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::Address" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Address" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::Signer" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Signer" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_record_field (|
                        γ,
                        "move_binary_format::normalized::Type::Struct",
                        "address"
                      |) in
                    let γ1_1 :=
                      M.SubPointer.get_struct_record_field (|
                        γ,
                        "move_binary_format::normalized::Type::Struct",
                        "module"
                      |) in
                    let γ1_2 :=
                      M.SubPointer.get_struct_record_field (|
                        γ,
                        "move_binary_format::normalized::Type::Struct",
                        "name"
                      |) in
                    let γ1_3 :=
                      M.SubPointer.get_struct_record_field (|
                        γ,
                        "move_binary_format::normalized::Type::Struct",
                        "type_arguments"
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    let __self_1 := M.alloc (| γ1_1 |) in
                    let __self_2 := M.alloc (| γ1_2 |) in
                    let __self_3 := M.alloc (| γ1_3 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_struct_field4_finish",
                          []
                        |),
                        [
                          M.read (| f |);
                          M.read (| Value.String "Struct" |);
                          M.read (| Value.String "address" |);
                          M.read (| __self_0 |);
                          M.read (| Value.String "module" |);
                          M.read (| __self_1 |);
                          M.read (| Value.String "name" |);
                          M.read (| __self_2 |);
                          M.read (| Value.String "type_arguments" |);
                          __self_3
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Type::Vector",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Vector" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Type::TypeParameter",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "TypeParameter" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Type::Reference",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Reference" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Type::MutableReference",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "MutableReference" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U16" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "U16" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U32" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "U32" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U256" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "U256" |) ]
                      |)
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::fmt::Debug"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
  End Impl_core_fmt_Debug_for_move_binary_format_normalized_Type.
  
  Module Impl_core_cmp_Ord_for_move_binary_format_normalized_Type.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Type".
    
    (* Ord *)
    Definition cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ __self_discr :=
              M.alloc (|
                M.call_closure (|
                  M.get_function (|
                    "core::intrinsics::discriminant_value",
                    [ Ty.path "move_binary_format::normalized::Type" ]
                  |),
                  [ M.read (| self |) ]
                |)
              |) in
            let~ __arg1_discr :=
              M.alloc (|
                M.call_closure (|
                  M.get_function (|
                    "core::intrinsics::discriminant_value",
                    [ Ty.path "move_binary_format::normalized::Type" ]
                  |),
                  [ M.read (| other |) ]
                |)
              |) in
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::Ord", Ty.path "isize", [], "cmp", [] |),
                  [ __self_discr; __arg1_discr ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [ M.read (| self |); M.read (| other |) ] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_record_field (|
                                γ0_0,
                                "move_binary_format::normalized::Type::Struct",
                                "address"
                              |) in
                            let γ2_1 :=
                              M.SubPointer.get_struct_record_field (|
                                γ0_0,
                                "move_binary_format::normalized::Type::Struct",
                                "module"
                              |) in
                            let γ2_2 :=
                              M.SubPointer.get_struct_record_field (|
                                γ0_0,
                                "move_binary_format::normalized::Type::Struct",
                                "name"
                              |) in
                            let γ2_3 :=
                              M.SubPointer.get_struct_record_field (|
                                γ0_0,
                                "move_binary_format::normalized::Type::Struct",
                                "type_arguments"
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let __self_1 := M.alloc (| γ2_1 |) in
                            let __self_2 := M.alloc (| γ2_2 |) in
                            let __self_3 := M.alloc (| γ2_3 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_record_field (|
                                γ0_1,
                                "move_binary_format::normalized::Type::Struct",
                                "address"
                              |) in
                            let γ2_1 :=
                              M.SubPointer.get_struct_record_field (|
                                γ0_1,
                                "move_binary_format::normalized::Type::Struct",
                                "module"
                              |) in
                            let γ2_2 :=
                              M.SubPointer.get_struct_record_field (|
                                γ0_1,
                                "move_binary_format::normalized::Type::Struct",
                                "name"
                              |) in
                            let γ2_3 :=
                              M.SubPointer.get_struct_record_field (|
                                γ0_1,
                                "move_binary_format::normalized::Type::Struct",
                                "type_arguments"
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            let __arg1_1 := M.alloc (| γ2_1 |) in
                            let __arg1_2 := M.alloc (| γ2_2 |) in
                            let __arg1_3 := M.alloc (| γ2_3 |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::Ord",
                                    Ty.path "move_core_types::account_address::AccountAddress",
                                    [],
                                    "cmp",
                                    []
                                  |),
                                  [ M.read (| __self_0 |); M.read (| __arg1_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",
                                            Ty.path "move_core_types::identifier::Identifier",
                                            [],
                                            "cmp",
                                            []
                                          |),
                                          [ M.read (| __self_1 |); M.read (| __arg1_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",
                                                    Ty.path
                                                      "move_core_types::identifier::Identifier",
                                                    [],
                                                    "cmp",
                                                    []
                                                  |),
                                                  [ M.read (| __self_2 |); M.read (| __arg1_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",
                                                          Ty.apply
                                                            (Ty.path "alloc::vec::Vec")
                                                            []
                                                            [
                                                              Ty.path
                                                                "move_binary_format::normalized::Type";
                                                              Ty.path "alloc::alloc::Global"
                                                            ],
                                                          [],
                                                          "cmp",
                                                          []
                                                        |),
                                                        [
                                                          M.read (| __self_3 |);
                                                          M.read (| __arg1_3 |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let cmp := M.copy (| γ |) in
                                                    cmp))
                                              ]
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let cmp := M.copy (| γ |) in
                                            cmp))
                                      ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let cmp := M.copy (| γ |) in
                                    cmp))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Type::Vector",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Type::Vector",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.apply
                                    (Ty.path "alloc::boxed::Box")
                                    []
                                    [
                                      Ty.path "move_binary_format::normalized::Type";
                                      Ty.path "alloc::alloc::Global"
                                    ],
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Type::TypeParameter",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Type::TypeParameter",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "u16",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Type::Reference",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Type::Reference",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.apply
                                    (Ty.path "alloc::boxed::Box")
                                    []
                                    [
                                      Ty.path "move_binary_format::normalized::Type";
                                      Ty.path "alloc::alloc::Global"
                                    ],
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Type::MutableReference",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Type::MutableReference",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.apply
                                    (Ty.path "alloc::boxed::Box")
                                    []
                                    [
                                      Ty.path "move_binary_format::normalized::Type";
                                      Ty.path "alloc::alloc::Global"
                                    ],
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (M.alloc (| Value.StructTuple "core::cmp::Ordering::Equal" [] |)))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let cmp := M.copy (| γ |) in
                    cmp))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::Ord"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("cmp", InstanceField.Method cmp) ].
  End Impl_core_cmp_Ord_for_move_binary_format_normalized_Type.
  
  Module Impl_core_cmp_PartialOrd_for_move_binary_format_normalized_Type.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Type".
    
    (* PartialOrd *)
    Definition partial_cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ __self_discr :=
              M.alloc (|
                M.call_closure (|
                  M.get_function (|
                    "core::intrinsics::discriminant_value",
                    [ Ty.path "move_binary_format::normalized::Type" ]
                  |),
                  [ M.read (| self |) ]
                |)
              |) in
            let~ __arg1_discr :=
              M.alloc (|
                M.call_closure (|
                  M.get_function (|
                    "core::intrinsics::discriminant_value",
                    [ Ty.path "move_binary_format::normalized::Type" ]
                  |),
                  [ M.read (| other |) ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [ M.read (| self |); M.read (| other |) ] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                    let γ0_0 := M.read (| γ0_0 |) in
                    let γ2_0 :=
                      M.SubPointer.get_struct_record_field (|
                        γ0_0,
                        "move_binary_format::normalized::Type::Struct",
                        "address"
                      |) in
                    let γ2_1 :=
                      M.SubPointer.get_struct_record_field (|
                        γ0_0,
                        "move_binary_format::normalized::Type::Struct",
                        "module"
                      |) in
                    let γ2_2 :=
                      M.SubPointer.get_struct_record_field (|
                        γ0_0,
                        "move_binary_format::normalized::Type::Struct",
                        "name"
                      |) in
                    let γ2_3 :=
                      M.SubPointer.get_struct_record_field (|
                        γ0_0,
                        "move_binary_format::normalized::Type::Struct",
                        "type_arguments"
                      |) in
                    let __self_0 := M.alloc (| γ2_0 |) in
                    let __self_1 := M.alloc (| γ2_1 |) in
                    let __self_2 := M.alloc (| γ2_2 |) in
                    let __self_3 := M.alloc (| γ2_3 |) in
                    let γ0_1 := M.read (| γ0_1 |) in
                    let γ2_0 :=
                      M.SubPointer.get_struct_record_field (|
                        γ0_1,
                        "move_binary_format::normalized::Type::Struct",
                        "address"
                      |) in
                    let γ2_1 :=
                      M.SubPointer.get_struct_record_field (|
                        γ0_1,
                        "move_binary_format::normalized::Type::Struct",
                        "module"
                      |) in
                    let γ2_2 :=
                      M.SubPointer.get_struct_record_field (|
                        γ0_1,
                        "move_binary_format::normalized::Type::Struct",
                        "name"
                      |) in
                    let γ2_3 :=
                      M.SubPointer.get_struct_record_field (|
                        γ0_1,
                        "move_binary_format::normalized::Type::Struct",
                        "type_arguments"
                      |) in
                    let __arg1_0 := M.alloc (| γ2_0 |) in
                    let __arg1_1 := M.alloc (| γ2_1 |) in
                    let __arg1_2 := M.alloc (| γ2_2 |) in
                    let __arg1_3 := M.alloc (| γ2_3 |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            Ty.path "move_core_types::account_address::AccountAddress",
                            [ Ty.path "move_core_types::account_address::AccountAddress" ],
                            "partial_cmp",
                            []
                          |),
                          [ M.read (| __self_0 |); M.read (| __arg1_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",
                                    Ty.path "move_core_types::identifier::Identifier",
                                    [ Ty.path "move_core_types::identifier::Identifier" ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [ M.read (| __self_1 |); M.read (| __arg1_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",
                                            Ty.path "move_core_types::identifier::Identifier",
                                            [ Ty.path "move_core_types::identifier::Identifier" ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [ M.read (| __self_2 |); M.read (| __arg1_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",
                                                  Ty.apply
                                                    (Ty.path "alloc::vec::Vec")
                                                    []
                                                    [
                                                      Ty.path
                                                        "move_binary_format::normalized::Type";
                                                      Ty.path "alloc::alloc::Global"
                                                    ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "alloc::vec::Vec")
                                                      []
                                                      [
                                                        Ty.path
                                                          "move_binary_format::normalized::Type";
                                                        Ty.path "alloc::alloc::Global"
                                                      ]
                                                  ],
                                                  "partial_cmp",
                                                  []
                                                |),
                                                [ M.read (| __self_3 |); M.read (| __arg1_3 |) ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let cmp := M.copy (| γ |) in
                                            cmp))
                                      ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let cmp := M.copy (| γ |) in
                                    cmp))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let cmp := M.copy (| γ |) in
                            cmp))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                    let γ0_0 := M.read (| γ0_0 |) in
                    let γ2_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ0_0,
                        "move_binary_format::normalized::Type::Vector",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ2_0 |) in
                    let γ0_1 := M.read (| γ0_1 |) in
                    let γ2_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ0_1,
                        "move_binary_format::normalized::Type::Vector",
                        0
                      |) in
                    let __arg1_0 := M.alloc (| γ2_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialOrd",
                          Ty.apply
                            (Ty.path "alloc::boxed::Box")
                            []
                            [
                              Ty.path "move_binary_format::normalized::Type";
                              Ty.path "alloc::alloc::Global"
                            ],
                          [
                            Ty.apply
                              (Ty.path "alloc::boxed::Box")
                              []
                              [
                                Ty.path "move_binary_format::normalized::Type";
                                Ty.path "alloc::alloc::Global"
                              ]
                          ],
                          "partial_cmp",
                          []
                        |),
                        [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                    let γ0_0 := M.read (| γ0_0 |) in
                    let γ2_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ0_0,
                        "move_binary_format::normalized::Type::TypeParameter",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ2_0 |) in
                    let γ0_1 := M.read (| γ0_1 |) in
                    let γ2_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ0_1,
                        "move_binary_format::normalized::Type::TypeParameter",
                        0
                      |) in
                    let __arg1_0 := M.alloc (| γ2_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialOrd",
                          Ty.path "u16",
                          [ Ty.path "u16" ],
                          "partial_cmp",
                          []
                        |),
                        [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                    let γ0_0 := M.read (| γ0_0 |) in
                    let γ2_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ0_0,
                        "move_binary_format::normalized::Type::Reference",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ2_0 |) in
                    let γ0_1 := M.read (| γ0_1 |) in
                    let γ2_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ0_1,
                        "move_binary_format::normalized::Type::Reference",
                        0
                      |) in
                    let __arg1_0 := M.alloc (| γ2_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialOrd",
                          Ty.apply
                            (Ty.path "alloc::boxed::Box")
                            []
                            [
                              Ty.path "move_binary_format::normalized::Type";
                              Ty.path "alloc::alloc::Global"
                            ],
                          [
                            Ty.apply
                              (Ty.path "alloc::boxed::Box")
                              []
                              [
                                Ty.path "move_binary_format::normalized::Type";
                                Ty.path "alloc::alloc::Global"
                              ]
                          ],
                          "partial_cmp",
                          []
                        |),
                        [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                    let γ0_0 := M.read (| γ0_0 |) in
                    let γ2_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ0_0,
                        "move_binary_format::normalized::Type::MutableReference",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ2_0 |) in
                    let γ0_1 := M.read (| γ0_1 |) in
                    let γ2_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ0_1,
                        "move_binary_format::normalized::Type::MutableReference",
                        0
                      |) in
                    let __arg1_0 := M.alloc (| γ2_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialOrd",
                          Ty.apply
                            (Ty.path "alloc::boxed::Box")
                            []
                            [
                              Ty.path "move_binary_format::normalized::Type";
                              Ty.path "alloc::alloc::Global"
                            ],
                          [
                            Ty.apply
                              (Ty.path "alloc::boxed::Box")
                              []
                              [
                                Ty.path "move_binary_format::normalized::Type";
                                Ty.path "alloc::alloc::Global"
                              ]
                          ],
                          "partial_cmp",
                          []
                        |),
                        [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialOrd",
                          Ty.path "isize",
                          [ Ty.path "isize" ],
                          "partial_cmp",
                          []
                        |),
                        [ __self_discr; __arg1_discr ]
                      |)
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::PartialOrd"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("partial_cmp", InstanceField.Method partial_cmp) ].
  End Impl_core_cmp_PartialOrd_for_move_binary_format_normalized_Type.
  
  Module Impl_core_cmp_Eq_for_move_binary_format_normalized_Type.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Type".
    
    (* Eq *)
    Definition assert_receiver_is_total_eq
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.read (|
            M.match_operator (|
              Value.DeclaredButUndefined,
              [
                fun γ =>
                  ltac:(M.monadic
                    (M.match_operator (|
                      Value.DeclaredButUndefined,
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              Value.DeclaredButUndefined,
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (M.match_operator (|
                                      Value.DeclaredButUndefined,
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.match_operator (|
                                              Value.DeclaredButUndefined,
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (M.match_operator (|
                                                      Value.DeclaredButUndefined,
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (M.match_operator (|
                                                              Value.DeclaredButUndefined,
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (M.alloc (| Value.Tuple [] |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::Eq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *)
        [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ].
  End Impl_core_cmp_Eq_for_move_binary_format_normalized_Type.
  
  Module Impl_core_marker_StructuralPartialEq_for_move_binary_format_normalized_Type.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Type".
    
    Axiom Implements :
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_move_binary_format_normalized_Type.
  
  Module Impl_core_cmp_PartialEq_for_move_binary_format_normalized_Type.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Type".
    
    (* PartialEq *)
    Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ __self_discr :=
              M.alloc (|
                M.call_closure (|
                  M.get_function (|
                    "core::intrinsics::discriminant_value",
                    [ Ty.path "move_binary_format::normalized::Type" ]
                  |),
                  [ M.read (| self |) ]
                |)
              |) in
            let~ __arg1_discr :=
              M.alloc (|
                M.call_closure (|
                  M.get_function (|
                    "core::intrinsics::discriminant_value",
                    [ Ty.path "move_binary_format::normalized::Type" ]
                  |),
                  [ M.read (| other |) ]
                |)
              |) in
            M.alloc (|
              LogicalOp.and (|
                BinOp.eq (| M.read (| __self_discr |), M.read (| __arg1_discr |) |),
                ltac:(M.monadic
                  (M.read (|
                    M.match_operator (|
                      M.alloc (| Value.Tuple [ M.read (| self |); M.read (| other |) ] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_record_field (|
                                γ0_0,
                                "move_binary_format::normalized::Type::Struct",
                                "address"
                              |) in
                            let γ2_1 :=
                              M.SubPointer.get_struct_record_field (|
                                γ0_0,
                                "move_binary_format::normalized::Type::Struct",
                                "module"
                              |) in
                            let γ2_2 :=
                              M.SubPointer.get_struct_record_field (|
                                γ0_0,
                                "move_binary_format::normalized::Type::Struct",
                                "name"
                              |) in
                            let γ2_3 :=
                              M.SubPointer.get_struct_record_field (|
                                γ0_0,
                                "move_binary_format::normalized::Type::Struct",
                                "type_arguments"
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let __self_1 := M.alloc (| γ2_1 |) in
                            let __self_2 := M.alloc (| γ2_2 |) in
                            let __self_3 := M.alloc (| γ2_3 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_record_field (|
                                γ0_1,
                                "move_binary_format::normalized::Type::Struct",
                                "address"
                              |) in
                            let γ2_1 :=
                              M.SubPointer.get_struct_record_field (|
                                γ0_1,
                                "move_binary_format::normalized::Type::Struct",
                                "module"
                              |) in
                            let γ2_2 :=
                              M.SubPointer.get_struct_record_field (|
                                γ0_1,
                                "move_binary_format::normalized::Type::Struct",
                                "name"
                              |) in
                            let γ2_3 :=
                              M.SubPointer.get_struct_record_field (|
                                γ0_1,
                                "move_binary_format::normalized::Type::Struct",
                                "type_arguments"
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            let __arg1_1 := M.alloc (| γ2_1 |) in
                            let __arg1_2 := M.alloc (| γ2_2 |) in
                            let __arg1_3 := M.alloc (| γ2_3 |) in
                            M.alloc (|
                              LogicalOp.and (|
                                LogicalOp.and (|
                                  LogicalOp.and (|
                                    M.call_closure (|
                                      M.get_trait_method (|
                                        "core::cmp::PartialEq",
                                        Ty.apply
                                          (Ty.path "&")
                                          []
                                          [
                                            Ty.path
                                              "move_core_types::account_address::AccountAddress"
                                          ],
                                        [
                                          Ty.apply
                                            (Ty.path "&")
                                            []
                                            [
                                              Ty.path
                                                "move_core_types::account_address::AccountAddress"
                                            ]
                                        ],
                                        "eq",
                                        []
                                      |),
                                      [ __self_0; __arg1_0 ]
                                    |),
                                    ltac:(M.monadic
                                      (M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "&")
                                            []
                                            [ Ty.path "move_core_types::identifier::Identifier" ],
                                          [
                                            Ty.apply
                                              (Ty.path "&")
                                              []
                                              [ Ty.path "move_core_types::identifier::Identifier" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [ __self_1; __arg1_1 ]
                                      |)))
                                  |),
                                  ltac:(M.monadic
                                    (M.call_closure (|
                                      M.get_trait_method (|
                                        "core::cmp::PartialEq",
                                        Ty.apply
                                          (Ty.path "&")
                                          []
                                          [ Ty.path "move_core_types::identifier::Identifier" ],
                                        [
                                          Ty.apply
                                            (Ty.path "&")
                                            []
                                            [ Ty.path "move_core_types::identifier::Identifier" ]
                                        ],
                                        "eq",
                                        []
                                      |),
                                      [ __self_2; __arg1_2 ]
                                    |)))
                                |),
                                ltac:(M.monadic
                                  (M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "&")
                                        []
                                        [
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path "move_binary_format::normalized::Type";
                                              Ty.path "alloc::alloc::Global"
                                            ]
                                        ],
                                      [
                                        Ty.apply
                                          (Ty.path "&")
                                          []
                                          [
                                            Ty.apply
                                              (Ty.path "alloc::vec::Vec")
                                              []
                                              [
                                                Ty.path "move_binary_format::normalized::Type";
                                                Ty.path "alloc::alloc::Global"
                                              ]
                                          ]
                                      ],
                                      "eq",
                                      []
                                    |),
                                    [ __self_3; __arg1_3 ]
                                  |)))
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Type::Vector",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Type::Vector",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [
                                      Ty.apply
                                        (Ty.path "alloc::boxed::Box")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [
                                        Ty.apply
                                          (Ty.path "alloc::boxed::Box")
                                          []
                                          [
                                            Ty.path "move_binary_format::normalized::Type";
                                            Ty.path "alloc::alloc::Global"
                                          ]
                                      ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Type::TypeParameter",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Type::TypeParameter",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply (Ty.path "&") [] [ Ty.path "u16" ],
                                  [ Ty.apply (Ty.path "&") [] [ Ty.path "u16" ] ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Type::Reference",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Type::Reference",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [
                                      Ty.apply
                                        (Ty.path "alloc::boxed::Box")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [
                                        Ty.apply
                                          (Ty.path "alloc::boxed::Box")
                                          []
                                          [
                                            Ty.path "move_binary_format::normalized::Type";
                                            Ty.path "alloc::alloc::Global"
                                          ]
                                      ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Type::MutableReference",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Type::MutableReference",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [
                                      Ty.apply
                                        (Ty.path "alloc::boxed::Box")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [
                                        Ty.apply
                                          (Ty.path "alloc::boxed::Box")
                                          []
                                          [
                                            Ty.path "move_binary_format::normalized::Type";
                                            Ty.path "alloc::alloc::Global"
                                          ]
                                      ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ => ltac:(M.monadic (M.alloc (| Value.Bool true |)))
                      ]
                    |)
                  |)))
              |)
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::PartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("eq", InstanceField.Method eq) ].
  End Impl_core_cmp_PartialEq_for_move_binary_format_normalized_Type.
  
  Module underscore.
    Module Impl_serde_ser_Serialize_for_move_binary_format_normalized_Type.
      Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Type".
      
      (* Serialize *)
      Definition serialize (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __S ], [ self; __serializer ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let __serializer := M.alloc (| __serializer |) in
            M.catch_return (|
              ltac:(M.monadic
                (M.read (|
                  M.match_operator (|
                    M.read (| self |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Type::Bool"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Type" |);
                                Value.Integer IntegerKind.U32 0;
                                M.read (| Value.String "bool" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U8" |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Type" |);
                                Value.Integer IntegerKind.U32 1;
                                M.read (| Value.String "u8" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Type::U64"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Type" |);
                                Value.Integer IntegerKind.U32 2;
                                M.read (| Value.String "u64" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Type::U128"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Type" |);
                                Value.Integer IntegerKind.U32 3;
                                M.read (| Value.String "u128" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Type::Address"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Type" |);
                                Value.Integer IntegerKind.U32 4;
                                M.read (| Value.String "address" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Type::Signer"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Type" |);
                                Value.Integer IntegerKind.U32 5;
                                M.read (| Value.String "signer" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_record_field (|
                              γ,
                              "move_binary_format::normalized::Type::Struct",
                              "address"
                            |) in
                          let γ0_1 :=
                            M.SubPointer.get_struct_record_field (|
                              γ,
                              "move_binary_format::normalized::Type::Struct",
                              "module"
                            |) in
                          let γ0_2 :=
                            M.SubPointer.get_struct_record_field (|
                              γ,
                              "move_binary_format::normalized::Type::Struct",
                              "name"
                            |) in
                          let γ0_3 :=
                            M.SubPointer.get_struct_record_field (|
                              γ,
                              "move_binary_format::normalized::Type::Struct",
                              "type_arguments"
                            |) in
                          let address := M.alloc (| γ0_0 |) in
                          let module := M.alloc (| γ0_1 |) in
                          let name := M.alloc (| γ0_2 |) in
                          let type_arguments := M.alloc (| γ0_3 |) in
                          let~ __serde_state :=
                            M.copy (|
                              M.match_operator (|
                                M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "serde::ser::Serializer",
                                      __S,
                                      [],
                                      "serialize_struct_variant",
                                      []
                                    |),
                                    [
                                      M.read (| __serializer |);
                                      M.read (| Value.String "Type" |);
                                      Value.Integer IntegerKind.U32 6;
                                      M.read (| Value.String "Struct" |);
                                      BinOp.Wrap.add (|
                                        BinOp.Wrap.add (|
                                          BinOp.Wrap.add (|
                                            BinOp.Wrap.add (|
                                              Value.Integer IntegerKind.Usize 0,
                                              Value.Integer IntegerKind.Usize 1
                                            |),
                                            Value.Integer IntegerKind.Usize 1
                                          |),
                                          Value.Integer IntegerKind.Usize 1
                                        |),
                                        Value.Integer IntegerKind.Usize 1
                                      |)
                                    ]
                                  |)
                                |),
                                [
                                  fun γ =>
                                    ltac:(M.monadic
                                      (let γ0_0 :=
                                        M.SubPointer.get_struct_tuple_field (|
                                          γ,
                                          "core::result::Result::Ok",
                                          0
                                        |) in
                                      let __val := M.copy (| γ0_0 |) in
                                      __val));
                                  fun γ =>
                                    ltac:(M.monadic
                                      (let γ0_0 :=
                                        M.SubPointer.get_struct_tuple_field (|
                                          γ,
                                          "core::result::Result::Err",
                                          0
                                        |) in
                                      let __err := M.copy (| γ0_0 |) in
                                      M.alloc (|
                                        M.never_to_any (|
                                          M.read (|
                                            M.return_ (|
                                              Value.StructTuple
                                                "core::result::Result::Err"
                                                [ M.read (| __err |) ]
                                            |)
                                          |)
                                        |)
                                      |)))
                                ]
                              |)
                            |) in
                          let~ _ :=
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "serde::ser::SerializeStructVariant",
                                    Ty.associated,
                                    [],
                                    "serialize_field",
                                    [ Ty.path "move_core_types::account_address::AccountAddress" ]
                                  |),
                                  [
                                    __serde_state;
                                    M.read (| Value.String "address" |);
                                    M.read (| address |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let __val := M.copy (| γ0_0 |) in
                                    __val));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let __err := M.copy (| γ0_0 |) in
                                    M.alloc (|
                                      M.never_to_any (|
                                        M.read (|
                                          M.return_ (|
                                            Value.StructTuple
                                              "core::result::Result::Err"
                                              [ M.read (| __err |) ]
                                          |)
                                        |)
                                      |)
                                    |)))
                              ]
                            |) in
                          let~ _ :=
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "serde::ser::SerializeStructVariant",
                                    Ty.associated,
                                    [],
                                    "serialize_field",
                                    [ Ty.path "move_core_types::identifier::Identifier" ]
                                  |),
                                  [
                                    __serde_state;
                                    M.read (| Value.String "module" |);
                                    M.read (| module |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let __val := M.copy (| γ0_0 |) in
                                    __val));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let __err := M.copy (| γ0_0 |) in
                                    M.alloc (|
                                      M.never_to_any (|
                                        M.read (|
                                          M.return_ (|
                                            Value.StructTuple
                                              "core::result::Result::Err"
                                              [ M.read (| __err |) ]
                                          |)
                                        |)
                                      |)
                                    |)))
                              ]
                            |) in
                          let~ _ :=
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "serde::ser::SerializeStructVariant",
                                    Ty.associated,
                                    [],
                                    "serialize_field",
                                    [ Ty.path "move_core_types::identifier::Identifier" ]
                                  |),
                                  [
                                    __serde_state;
                                    M.read (| Value.String "name" |);
                                    M.read (| name |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let __val := M.copy (| γ0_0 |) in
                                    __val));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let __err := M.copy (| γ0_0 |) in
                                    M.alloc (|
                                      M.never_to_any (|
                                        M.read (|
                                          M.return_ (|
                                            Value.StructTuple
                                              "core::result::Result::Err"
                                              [ M.read (| __err |) ]
                                          |)
                                        |)
                                      |)
                                    |)))
                              ]
                            |) in
                          let~ _ :=
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "serde::ser::SerializeStructVariant",
                                    Ty.associated,
                                    [],
                                    "serialize_field",
                                    [
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ]
                                  |),
                                  [
                                    __serde_state;
                                    M.read (| Value.String "type_arguments" |);
                                    M.read (| type_arguments |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let __val := M.copy (| γ0_0 |) in
                                    __val));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let __err := M.copy (| γ0_0 |) in
                                    M.alloc (|
                                      M.never_to_any (|
                                        M.read (|
                                          M.return_ (|
                                            Value.StructTuple
                                              "core::result::Result::Err"
                                              [ M.read (| __err |) ]
                                          |)
                                        |)
                                      |)
                                    |)))
                              ]
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::SerializeStructVariant",
                                Ty.associated,
                                [],
                                "end",
                                []
                              |),
                              [ M.read (| __serde_state |) ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Type::Vector",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [
                                  Ty.apply
                                    (Ty.path "alloc::boxed::Box")
                                    []
                                    [
                                      Ty.path "move_binary_format::normalized::Type";
                                      Ty.path "alloc::alloc::Global"
                                    ]
                                ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Type" |);
                                Value.Integer IntegerKind.U32 7;
                                M.read (| Value.String "vector" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Type::TypeParameter",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "u16" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Type" |);
                                Value.Integer IntegerKind.U32 8;
                                M.read (| Value.String "TypeParameter" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Type::Reference",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [
                                  Ty.apply
                                    (Ty.path "alloc::boxed::Box")
                                    []
                                    [
                                      Ty.path "move_binary_format::normalized::Type";
                                      Ty.path "alloc::alloc::Global"
                                    ]
                                ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Type" |);
                                Value.Integer IntegerKind.U32 9;
                                M.read (| Value.String "Reference" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Type::MutableReference",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [
                                  Ty.apply
                                    (Ty.path "alloc::boxed::Box")
                                    []
                                    [
                                      Ty.path "move_binary_format::normalized::Type";
                                      Ty.path "alloc::alloc::Global"
                                    ]
                                ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Type" |);
                                Value.Integer IntegerKind.U32 10;
                                M.read (| Value.String "MutableReference" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Type::U16"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Type" |);
                                Value.Integer IntegerKind.U32 11;
                                M.read (| Value.String "u16" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Type::U32"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Type" |);
                                Value.Integer IntegerKind.U32 12;
                                M.read (| Value.String "u32" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Type::U256"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Type" |);
                                Value.Integer IntegerKind.U32 13;
                                M.read (| Value.String "u256" |)
                              ]
                            |)
                          |)))
                    ]
                  |)
                |)))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "serde::ser::Serialize"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("serialize", InstanceField.Method serialize) ].
    End Impl_serde_ser_Serialize_for_move_binary_format_normalized_Type.
    Module Impl_serde_de_Deserialize_for_move_binary_format_normalized_Type.
      Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Type".
      
      (* Deserialize *)
      Definition deserialize (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __D ], [ __deserializer ] =>
          ltac:(M.monadic
            (let __deserializer := M.alloc (| __deserializer |) in
            M.call_closure (|
              M.get_trait_method (|
                "serde::de::Deserializer",
                __D,
                [],
                "deserialize_enum",
                [ Ty.path "move_binary_format::normalized::_'1::deserialize::__Visitor" ]
              |),
              [
                M.read (| __deserializer |);
                M.read (| Value.String "Type" |);
                M.read (|
                  M.get_constant (| "move_binary_format::normalized::_'1::deserialize::VARIANTS" |)
                |);
                Value.StructRecord
                  "move_binary_format::normalized::_'1::deserialize::__Visitor"
                  [
                    ("marker", Value.StructTuple "core::marker::PhantomData" []);
                    ("lifetime", Value.StructTuple "core::marker::PhantomData" [])
                  ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "serde::de::Deserialize"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("deserialize", InstanceField.Method deserialize) ].
    End Impl_serde_de_Deserialize_for_move_binary_format_normalized_Type.
    Module Impl_serde_ser_Serialize_for_move_binary_format_normalized_Field.
      Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Field".
      
      (* Serialize *)
      Definition serialize (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __S ], [ self; __serializer ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let __serializer := M.alloc (| __serializer |) in
            M.catch_return (|
              ltac:(M.monadic
                (M.read (|
                  let~ __serde_state :=
                    M.copy (|
                      M.match_operator (|
                        M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "serde::ser::Serializer",
                              __S,
                              [],
                              "serialize_struct",
                              []
                            |),
                            [
                              M.read (| __serializer |);
                              M.read (| Value.String "Field" |);
                              BinOp.Wrap.add (|
                                BinOp.Wrap.add (|
                                  M.rust_cast (Value.Bool false),
                                  Value.Integer IntegerKind.Usize 1
                                |),
                                Value.Integer IntegerKind.Usize 1
                              |)
                            ]
                          |)
                        |),
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ,
                                  "core::result::Result::Ok",
                                  0
                                |) in
                              let __val := M.copy (| γ0_0 |) in
                              __val));
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ,
                                  "core::result::Result::Err",
                                  0
                                |) in
                              let __err := M.copy (| γ0_0 |) in
                              M.alloc (|
                                M.never_to_any (|
                                  M.read (|
                                    M.return_ (|
                                      Value.StructTuple
                                        "core::result::Result::Err"
                                        [ M.read (| __err |) ]
                                    |)
                                  |)
                                |)
                              |)))
                        ]
                      |)
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [ Ty.path "move_core_types::identifier::Identifier" ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "name" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Field",
                              "name"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [ Ty.path "move_binary_format::normalized::Type" ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "type_" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Field",
                              "type_"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "serde::ser::SerializeStruct",
                        Ty.associated,
                        [],
                        "end",
                        []
                      |),
                      [ M.read (| __serde_state |) ]
                    |)
                  |)
                |)))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "serde::ser::Serialize"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("serialize", InstanceField.Method serialize) ].
    End Impl_serde_ser_Serialize_for_move_binary_format_normalized_Field.
    Module Impl_serde_de_Deserialize_for_move_binary_format_normalized_Field.
      Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Field".
      
      (* Deserialize *)
      Definition deserialize (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __D ], [ __deserializer ] =>
          ltac:(M.monadic
            (let __deserializer := M.alloc (| __deserializer |) in
            M.call_closure (|
              M.get_trait_method (|
                "serde::de::Deserializer",
                __D,
                [],
                "deserialize_struct",
                [ Ty.path "move_binary_format::normalized::_'3::deserialize::__Visitor" ]
              |),
              [
                M.read (| __deserializer |);
                M.read (| Value.String "Field" |);
                M.read (|
                  M.get_constant (| "move_binary_format::normalized::_'3::deserialize::FIELDS" |)
                |);
                Value.StructRecord
                  "move_binary_format::normalized::_'3::deserialize::__Visitor"
                  [
                    ("marker", Value.StructTuple "core::marker::PhantomData" []);
                    ("lifetime", Value.StructTuple "core::marker::PhantomData" [])
                  ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "serde::de::Deserialize"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("deserialize", InstanceField.Method deserialize) ].
    End Impl_serde_de_Deserialize_for_move_binary_format_normalized_Field.
    Module Impl_serde_ser_Serialize_for_move_binary_format_normalized_Constant.
      Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Constant".
      
      (* Serialize *)
      Definition serialize (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __S ], [ self; __serializer ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let __serializer := M.alloc (| __serializer |) in
            M.catch_return (|
              ltac:(M.monadic
                (M.read (|
                  let~ __serde_state :=
                    M.copy (|
                      M.match_operator (|
                        M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "serde::ser::Serializer",
                              __S,
                              [],
                              "serialize_struct",
                              []
                            |),
                            [
                              M.read (| __serializer |);
                              M.read (| Value.String "Constant" |);
                              BinOp.Wrap.add (|
                                BinOp.Wrap.add (|
                                  M.rust_cast (Value.Bool false),
                                  Value.Integer IntegerKind.Usize 1
                                |),
                                Value.Integer IntegerKind.Usize 1
                              |)
                            ]
                          |)
                        |),
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ,
                                  "core::result::Result::Ok",
                                  0
                                |) in
                              let __val := M.copy (| γ0_0 |) in
                              __val));
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ,
                                  "core::result::Result::Err",
                                  0
                                |) in
                              let __err := M.copy (| γ0_0 |) in
                              M.alloc (|
                                M.never_to_any (|
                                  M.read (|
                                    M.return_ (|
                                      Value.StructTuple
                                        "core::result::Result::Err"
                                        [ M.read (| __err |) ]
                                    |)
                                  |)
                                |)
                              |)))
                        ]
                      |)
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [ Ty.path "move_binary_format::normalized::Type" ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "type_" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Constant",
                              "type_"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [
                              Ty.apply
                                (Ty.path "alloc::vec::Vec")
                                []
                                [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ]
                            ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "data" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Constant",
                              "data"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "serde::ser::SerializeStruct",
                        Ty.associated,
                        [],
                        "end",
                        []
                      |),
                      [ M.read (| __serde_state |) ]
                    |)
                  |)
                |)))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "serde::ser::Serialize"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("serialize", InstanceField.Method serialize) ].
    End Impl_serde_ser_Serialize_for_move_binary_format_normalized_Constant.
    Module Impl_serde_de_Deserialize_for_move_binary_format_normalized_Constant.
      Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Constant".
      
      (* Deserialize *)
      Definition deserialize (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __D ], [ __deserializer ] =>
          ltac:(M.monadic
            (let __deserializer := M.alloc (| __deserializer |) in
            M.call_closure (|
              M.get_trait_method (|
                "serde::de::Deserializer",
                __D,
                [],
                "deserialize_struct",
                [ Ty.path "move_binary_format::normalized::_'5::deserialize::__Visitor" ]
              |),
              [
                M.read (| __deserializer |);
                M.read (| Value.String "Constant" |);
                M.read (|
                  M.get_constant (| "move_binary_format::normalized::_'5::deserialize::FIELDS" |)
                |);
                Value.StructRecord
                  "move_binary_format::normalized::_'5::deserialize::__Visitor"
                  [
                    ("marker", Value.StructTuple "core::marker::PhantomData" []);
                    ("lifetime", Value.StructTuple "core::marker::PhantomData" [])
                  ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "serde::de::Deserialize"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("deserialize", InstanceField.Method deserialize) ].
    End Impl_serde_de_Deserialize_for_move_binary_format_normalized_Constant.
    Module Impl_serde_ser_Serialize_for_move_binary_format_normalized_Struct.
      Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Struct".
      
      (* Serialize *)
      Definition serialize (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __S ], [ self; __serializer ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let __serializer := M.alloc (| __serializer |) in
            M.catch_return (|
              ltac:(M.monadic
                (M.read (|
                  let~ __serde_state :=
                    M.copy (|
                      M.match_operator (|
                        M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "serde::ser::Serializer",
                              __S,
                              [],
                              "serialize_struct",
                              []
                            |),
                            [
                              M.read (| __serializer |);
                              M.read (| Value.String "Struct" |);
                              BinOp.Wrap.add (|
                                BinOp.Wrap.add (|
                                  BinOp.Wrap.add (|
                                    M.rust_cast (Value.Bool false),
                                    Value.Integer IntegerKind.Usize 1
                                  |),
                                  Value.Integer IntegerKind.Usize 1
                                |),
                                Value.Integer IntegerKind.Usize 1
                              |)
                            ]
                          |)
                        |),
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ,
                                  "core::result::Result::Ok",
                                  0
                                |) in
                              let __val := M.copy (| γ0_0 |) in
                              __val));
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ,
                                  "core::result::Result::Err",
                                  0
                                |) in
                              let __err := M.copy (| γ0_0 |) in
                              M.alloc (|
                                M.never_to_any (|
                                  M.read (|
                                    M.return_ (|
                                      Value.StructTuple
                                        "core::result::Result::Err"
                                        [ M.read (| __err |) ]
                                    |)
                                  |)
                                |)
                              |)))
                        ]
                      |)
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [ Ty.path "move_binary_format::file_format::AbilitySet" ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "abilities" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Struct",
                              "abilities"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [
                              Ty.apply
                                (Ty.path "alloc::vec::Vec")
                                []
                                [
                                  Ty.path "move_binary_format::file_format::StructTypeParameter";
                                  Ty.path "alloc::alloc::Global"
                                ]
                            ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "type_parameters" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Struct",
                              "type_parameters"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [
                              Ty.apply
                                (Ty.path "alloc::vec::Vec")
                                []
                                [
                                  Ty.path "move_binary_format::normalized::Field";
                                  Ty.path "alloc::alloc::Global"
                                ]
                            ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "fields" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Struct",
                              "fields"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "serde::ser::SerializeStruct",
                        Ty.associated,
                        [],
                        "end",
                        []
                      |),
                      [ M.read (| __serde_state |) ]
                    |)
                  |)
                |)))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "serde::ser::Serialize"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("serialize", InstanceField.Method serialize) ].
    End Impl_serde_ser_Serialize_for_move_binary_format_normalized_Struct.
    Module Impl_serde_de_Deserialize_for_move_binary_format_normalized_Struct.
      Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Struct".
      
      (* Deserialize *)
      Definition deserialize (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __D ], [ __deserializer ] =>
          ltac:(M.monadic
            (let __deserializer := M.alloc (| __deserializer |) in
            M.call_closure (|
              M.get_trait_method (|
                "serde::de::Deserializer",
                __D,
                [],
                "deserialize_struct",
                [ Ty.path "move_binary_format::normalized::_'7::deserialize::__Visitor" ]
              |),
              [
                M.read (| __deserializer |);
                M.read (| Value.String "Struct" |);
                M.read (|
                  M.get_constant (| "move_binary_format::normalized::_'7::deserialize::FIELDS" |)
                |);
                Value.StructRecord
                  "move_binary_format::normalized::_'7::deserialize::__Visitor"
                  [
                    ("marker", Value.StructTuple "core::marker::PhantomData" []);
                    ("lifetime", Value.StructTuple "core::marker::PhantomData" [])
                  ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "serde::de::Deserialize"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("deserialize", InstanceField.Method deserialize) ].
    End Impl_serde_de_Deserialize_for_move_binary_format_normalized_Struct.
    Module Impl_serde_ser_Serialize_for_move_binary_format_normalized_Function.
      Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Function".
      
      (* Serialize *)
      Definition serialize (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __S ], [ self; __serializer ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let __serializer := M.alloc (| __serializer |) in
            M.catch_return (|
              ltac:(M.monadic
                (M.read (|
                  let~ __serde_state :=
                    M.copy (|
                      M.match_operator (|
                        M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "serde::ser::Serializer",
                              __S,
                              [],
                              "serialize_struct",
                              []
                            |),
                            [
                              M.read (| __serializer |);
                              M.read (| Value.String "Function" |);
                              BinOp.Wrap.add (|
                                BinOp.Wrap.add (|
                                  BinOp.Wrap.add (|
                                    BinOp.Wrap.add (|
                                      BinOp.Wrap.add (|
                                        BinOp.Wrap.add (|
                                          M.rust_cast (Value.Bool false),
                                          Value.Integer IntegerKind.Usize 1
                                        |),
                                        Value.Integer IntegerKind.Usize 1
                                      |),
                                      Value.Integer IntegerKind.Usize 1
                                    |),
                                    Value.Integer IntegerKind.Usize 1
                                  |),
                                  Value.Integer IntegerKind.Usize 1
                                |),
                                Value.Integer IntegerKind.Usize 1
                              |)
                            ]
                          |)
                        |),
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ,
                                  "core::result::Result::Ok",
                                  0
                                |) in
                              let __val := M.copy (| γ0_0 |) in
                              __val));
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ,
                                  "core::result::Result::Err",
                                  0
                                |) in
                              let __err := M.copy (| γ0_0 |) in
                              M.alloc (|
                                M.never_to_any (|
                                  M.read (|
                                    M.return_ (|
                                      Value.StructTuple
                                        "core::result::Result::Err"
                                        [ M.read (| __err |) ]
                                    |)
                                  |)
                                |)
                              |)))
                        ]
                      |)
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [ Ty.path "move_binary_format::file_format::Visibility" ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "visibility" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Function",
                              "visibility"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [ Ty.path "bool" ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "is_entry" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Function",
                              "is_entry"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [
                              Ty.apply
                                (Ty.path "alloc::vec::Vec")
                                []
                                [
                                  Ty.path "move_binary_format::file_format::AbilitySet";
                                  Ty.path "alloc::alloc::Global"
                                ]
                            ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "type_parameters" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Function",
                              "type_parameters"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [
                              Ty.apply
                                (Ty.path "alloc::vec::Vec")
                                []
                                [
                                  Ty.path "move_binary_format::normalized::Type";
                                  Ty.path "alloc::alloc::Global"
                                ]
                            ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "parameters" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Function",
                              "parameters"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [
                              Ty.apply
                                (Ty.path "alloc::vec::Vec")
                                []
                                [
                                  Ty.path "move_binary_format::normalized::Type";
                                  Ty.path "alloc::alloc::Global"
                                ]
                            ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "return_" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Function",
                              "return_"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [
                              Ty.apply
                                (Ty.path "alloc::vec::Vec")
                                []
                                [
                                  Ty.path "move_binary_format::normalized::Bytecode";
                                  Ty.path "alloc::alloc::Global"
                                ]
                            ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "code" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Function",
                              "code"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "serde::ser::SerializeStruct",
                        Ty.associated,
                        [],
                        "end",
                        []
                      |),
                      [ M.read (| __serde_state |) ]
                    |)
                  |)
                |)))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "serde::ser::Serialize"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("serialize", InstanceField.Method serialize) ].
    End Impl_serde_ser_Serialize_for_move_binary_format_normalized_Function.
    Module Impl_serde_de_Deserialize_for_move_binary_format_normalized_Function.
      Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Function".
      
      (* Deserialize *)
      Definition deserialize (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __D ], [ __deserializer ] =>
          ltac:(M.monadic
            (let __deserializer := M.alloc (| __deserializer |) in
            M.call_closure (|
              M.get_trait_method (|
                "serde::de::Deserializer",
                __D,
                [],
                "deserialize_struct",
                [ Ty.path "move_binary_format::normalized::_'9::deserialize::__Visitor" ]
              |),
              [
                M.read (| __deserializer |);
                M.read (| Value.String "Function" |);
                M.read (|
                  M.get_constant (| "move_binary_format::normalized::_'9::deserialize::FIELDS" |)
                |);
                Value.StructRecord
                  "move_binary_format::normalized::_'9::deserialize::__Visitor"
                  [
                    ("marker", Value.StructTuple "core::marker::PhantomData" []);
                    ("lifetime", Value.StructTuple "core::marker::PhantomData" [])
                  ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "serde::de::Deserialize"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("deserialize", InstanceField.Method deserialize) ].
    End Impl_serde_de_Deserialize_for_move_binary_format_normalized_Function.
    Module Impl_serde_ser_Serialize_for_move_binary_format_normalized_FieldRef.
      Definition Self : Ty.t := Ty.path "move_binary_format::normalized::FieldRef".
      
      (* Serialize *)
      Definition serialize (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __S ], [ self; __serializer ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let __serializer := M.alloc (| __serializer |) in
            M.catch_return (|
              ltac:(M.monadic
                (M.read (|
                  let~ __serde_state :=
                    M.copy (|
                      M.match_operator (|
                        M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "serde::ser::Serializer",
                              __S,
                              [],
                              "serialize_struct",
                              []
                            |),
                            [
                              M.read (| __serializer |);
                              M.read (| Value.String "FieldRef" |);
                              BinOp.Wrap.add (|
                                BinOp.Wrap.add (|
                                  M.rust_cast (Value.Bool false),
                                  Value.Integer IntegerKind.Usize 1
                                |),
                                Value.Integer IntegerKind.Usize 1
                              |)
                            ]
                          |)
                        |),
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ,
                                  "core::result::Result::Ok",
                                  0
                                |) in
                              let __val := M.copy (| γ0_0 |) in
                              __val));
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ,
                                  "core::result::Result::Err",
                                  0
                                |) in
                              let __err := M.copy (| γ0_0 |) in
                              M.alloc (|
                                M.never_to_any (|
                                  M.read (|
                                    M.return_ (|
                                      Value.StructTuple
                                        "core::result::Result::Err"
                                        [ M.read (| __err |) ]
                                    |)
                                  |)
                                |)
                              |)))
                        ]
                      |)
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [ Ty.path "move_core_types::identifier::Identifier" ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "struct_name" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::FieldRef",
                              "struct_name"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [ Ty.path "u16" ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "field_index" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::FieldRef",
                              "field_index"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "serde::ser::SerializeStruct",
                        Ty.associated,
                        [],
                        "end",
                        []
                      |),
                      [ M.read (| __serde_state |) ]
                    |)
                  |)
                |)))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "serde::ser::Serialize"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("serialize", InstanceField.Method serialize) ].
    End Impl_serde_ser_Serialize_for_move_binary_format_normalized_FieldRef.
    Module Impl_serde_de_Deserialize_for_move_binary_format_normalized_FieldRef.
      Definition Self : Ty.t := Ty.path "move_binary_format::normalized::FieldRef".
      
      (* Deserialize *)
      Definition deserialize (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __D ], [ __deserializer ] =>
          ltac:(M.monadic
            (let __deserializer := M.alloc (| __deserializer |) in
            M.call_closure (|
              M.get_trait_method (|
                "serde::de::Deserializer",
                __D,
                [],
                "deserialize_struct",
                [ Ty.path "move_binary_format::normalized::_'11::deserialize::__Visitor" ]
              |),
              [
                M.read (| __deserializer |);
                M.read (| Value.String "FieldRef" |);
                M.read (|
                  M.get_constant (| "move_binary_format::normalized::_'11::deserialize::FIELDS" |)
                |);
                Value.StructRecord
                  "move_binary_format::normalized::_'11::deserialize::__Visitor"
                  [
                    ("marker", Value.StructTuple "core::marker::PhantomData" []);
                    ("lifetime", Value.StructTuple "core::marker::PhantomData" [])
                  ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "serde::de::Deserialize"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("deserialize", InstanceField.Method deserialize) ].
    End Impl_serde_de_Deserialize_for_move_binary_format_normalized_FieldRef.
    Module Impl_serde_ser_Serialize_for_move_binary_format_normalized_FunctionRef.
      Definition Self : Ty.t := Ty.path "move_binary_format::normalized::FunctionRef".
      
      (* Serialize *)
      Definition serialize (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __S ], [ self; __serializer ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let __serializer := M.alloc (| __serializer |) in
            M.catch_return (|
              ltac:(M.monadic
                (M.read (|
                  let~ __serde_state :=
                    M.copy (|
                      M.match_operator (|
                        M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "serde::ser::Serializer",
                              __S,
                              [],
                              "serialize_struct",
                              []
                            |),
                            [
                              M.read (| __serializer |);
                              M.read (| Value.String "FunctionRef" |);
                              BinOp.Wrap.add (|
                                BinOp.Wrap.add (|
                                  M.rust_cast (Value.Bool false),
                                  Value.Integer IntegerKind.Usize 1
                                |),
                                Value.Integer IntegerKind.Usize 1
                              |)
                            ]
                          |)
                        |),
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ,
                                  "core::result::Result::Ok",
                                  0
                                |) in
                              let __val := M.copy (| γ0_0 |) in
                              __val));
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ,
                                  "core::result::Result::Err",
                                  0
                                |) in
                              let __err := M.copy (| γ0_0 |) in
                              M.alloc (|
                                M.never_to_any (|
                                  M.read (|
                                    M.return_ (|
                                      Value.StructTuple
                                        "core::result::Result::Err"
                                        [ M.read (| __err |) ]
                                    |)
                                  |)
                                |)
                              |)))
                        ]
                      |)
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [ Ty.path "move_core_types::language_storage::ModuleId" ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "module_id" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::FunctionRef",
                              "module_id"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [ Ty.path "move_core_types::identifier::Identifier" ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "function_ident" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::FunctionRef",
                              "function_ident"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "serde::ser::SerializeStruct",
                        Ty.associated,
                        [],
                        "end",
                        []
                      |),
                      [ M.read (| __serde_state |) ]
                    |)
                  |)
                |)))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "serde::ser::Serialize"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("serialize", InstanceField.Method serialize) ].
    End Impl_serde_ser_Serialize_for_move_binary_format_normalized_FunctionRef.
    Module Impl_serde_de_Deserialize_for_move_binary_format_normalized_FunctionRef.
      Definition Self : Ty.t := Ty.path "move_binary_format::normalized::FunctionRef".
      
      (* Deserialize *)
      Definition deserialize (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __D ], [ __deserializer ] =>
          ltac:(M.monadic
            (let __deserializer := M.alloc (| __deserializer |) in
            M.call_closure (|
              M.get_trait_method (|
                "serde::de::Deserializer",
                __D,
                [],
                "deserialize_struct",
                [ Ty.path "move_binary_format::normalized::_'13::deserialize::__Visitor" ]
              |),
              [
                M.read (| __deserializer |);
                M.read (| Value.String "FunctionRef" |);
                M.read (|
                  M.get_constant (| "move_binary_format::normalized::_'13::deserialize::FIELDS" |)
                |);
                Value.StructRecord
                  "move_binary_format::normalized::_'13::deserialize::__Visitor"
                  [
                    ("marker", Value.StructTuple "core::marker::PhantomData" []);
                    ("lifetime", Value.StructTuple "core::marker::PhantomData" [])
                  ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "serde::de::Deserialize"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("deserialize", InstanceField.Method deserialize) ].
    End Impl_serde_de_Deserialize_for_move_binary_format_normalized_FunctionRef.
    Module Impl_serde_ser_Serialize_for_move_binary_format_normalized_Bytecode.
      Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Bytecode".
      
      (* Serialize *)
      Definition serialize (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __S ], [ self; __serializer ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let __serializer := M.alloc (| __serializer |) in
            M.catch_return (|
              ltac:(M.monadic
                (M.read (|
                  M.match_operator (|
                    M.read (| self |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Pop"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 0;
                                M.read (| Value.String "Pop" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Ret"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 1;
                                M.read (| Value.String "Ret" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::BrTrue",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "u16" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 2;
                                M.read (| Value.String "BrTrue" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::BrFalse",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "u16" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 3;
                                M.read (| Value.String "BrFalse" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Branch",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "u16" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 4;
                                M.read (| Value.String "Branch" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::LdU8",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "u8" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 5;
                                M.read (| Value.String "LdU8" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::LdU64",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "u64" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 6;
                                M.read (| Value.String "LdU64" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::LdU128",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "u128" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 7;
                                M.read (| Value.String "LdU128" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::CastU8"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 8;
                                M.read (| Value.String "CastU8" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::CastU64"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 9;
                                M.read (| Value.String "CastU64" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::CastU128"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 10;
                                M.read (| Value.String "CastU128" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::LdConst",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "move_binary_format::normalized::Constant" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 11;
                                M.read (| Value.String "LdConst" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::LdTrue"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 12;
                                M.read (| Value.String "LdTrue" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::LdFalse"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 13;
                                M.read (| Value.String "LdFalse" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::CopyLoc",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "u8" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 14;
                                M.read (| Value.String "CopyLoc" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::MoveLoc",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "u8" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 15;
                                M.read (| Value.String "MoveLoc" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::StLoc",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "u8" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 16;
                                M.read (| Value.String "StLoc" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Call",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "move_binary_format::normalized::FunctionRef" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 17;
                                M.read (| Value.String "Call" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::CallGeneric",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [
                                  Ty.tuple
                                    [
                                      Ty.path "move_binary_format::normalized::FunctionRef";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ]
                                ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 18;
                                M.read (| Value.String "CallGeneric" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Pack",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "move_core_types::identifier::Identifier" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 19;
                                M.read (| Value.String "Pack" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::PackGeneric",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [
                                  Ty.tuple
                                    [
                                      Ty.path "move_core_types::identifier::Identifier";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ]
                                ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 20;
                                M.read (| Value.String "PackGeneric" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Unpack",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "move_core_types::identifier::Identifier" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 21;
                                M.read (| Value.String "Unpack" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::UnpackGeneric",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [
                                  Ty.tuple
                                    [
                                      Ty.path "move_core_types::identifier::Identifier";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ]
                                ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 22;
                                M.read (| Value.String "UnpackGeneric" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::ReadRef"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 23;
                                M.read (| Value.String "ReadRef" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::WriteRef"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 24;
                                M.read (| Value.String "WriteRef" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::FreezeRef"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 25;
                                M.read (| Value.String "FreezeRef" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::MutBorrowLoc",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "u8" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 26;
                                M.read (| Value.String "MutBorrowLoc" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::ImmBorrowLoc",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "u8" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 27;
                                M.read (| Value.String "ImmBorrowLoc" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::MutBorrowField",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "move_binary_format::normalized::FieldRef" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 28;
                                M.read (| Value.String "MutBorrowField" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::MutBorrowFieldGeneric",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [
                                  Ty.tuple
                                    [
                                      Ty.path "move_binary_format::normalized::FieldRef";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ]
                                ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 29;
                                M.read (| Value.String "MutBorrowFieldGeneric" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::ImmBorrowField",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "move_binary_format::normalized::FieldRef" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 30;
                                M.read (| Value.String "ImmBorrowField" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::ImmBorrowFieldGeneric",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [
                                  Ty.tuple
                                    [
                                      Ty.path "move_binary_format::normalized::FieldRef";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ]
                                ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 31;
                                M.read (| Value.String "ImmBorrowFieldGeneric" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Add"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 32;
                                M.read (| Value.String "Add" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Sub"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 33;
                                M.read (| Value.String "Sub" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Mul"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 34;
                                M.read (| Value.String "Mul" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Mod"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 35;
                                M.read (| Value.String "Mod" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Div"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 36;
                                M.read (| Value.String "Div" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::BitOr"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 37;
                                M.read (| Value.String "BitOr" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::BitAnd"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 38;
                                M.read (| Value.String "BitAnd" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Xor"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 39;
                                M.read (| Value.String "Xor" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Or"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 40;
                                M.read (| Value.String "Or" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::And"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 41;
                                M.read (| Value.String "And" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Not"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 42;
                                M.read (| Value.String "Not" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Eq"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 43;
                                M.read (| Value.String "Eq" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Neq"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 44;
                                M.read (| Value.String "Neq" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Lt"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 45;
                                M.read (| Value.String "Lt" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Gt"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 46;
                                M.read (| Value.String "Gt" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Le"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 47;
                                M.read (| Value.String "Le" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Ge"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 48;
                                M.read (| Value.String "Ge" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Abort"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 49;
                                M.read (| Value.String "Abort" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Nop"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 50;
                                M.read (| Value.String "Nop" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Shl"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 51;
                                M.read (| Value.String "Shl" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::Shr"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 52;
                                M.read (| Value.String "Shr" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::VecPack",
                              0
                            |) in
                          let γ0_1 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::VecPack",
                              1
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          let __field1 := M.alloc (| γ0_1 |) in
                          let~ __serde_state :=
                            M.copy (|
                              M.match_operator (|
                                M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "serde::ser::Serializer",
                                      __S,
                                      [],
                                      "serialize_tuple_variant",
                                      []
                                    |),
                                    [
                                      M.read (| __serializer |);
                                      M.read (| Value.String "Bytecode" |);
                                      Value.Integer IntegerKind.U32 53;
                                      M.read (| Value.String "VecPack" |);
                                      BinOp.Wrap.add (|
                                        BinOp.Wrap.add (|
                                          Value.Integer IntegerKind.Usize 0,
                                          Value.Integer IntegerKind.Usize 1
                                        |),
                                        Value.Integer IntegerKind.Usize 1
                                      |)
                                    ]
                                  |)
                                |),
                                [
                                  fun γ =>
                                    ltac:(M.monadic
                                      (let γ0_0 :=
                                        M.SubPointer.get_struct_tuple_field (|
                                          γ,
                                          "core::result::Result::Ok",
                                          0
                                        |) in
                                      let __val := M.copy (| γ0_0 |) in
                                      __val));
                                  fun γ =>
                                    ltac:(M.monadic
                                      (let γ0_0 :=
                                        M.SubPointer.get_struct_tuple_field (|
                                          γ,
                                          "core::result::Result::Err",
                                          0
                                        |) in
                                      let __err := M.copy (| γ0_0 |) in
                                      M.alloc (|
                                        M.never_to_any (|
                                          M.read (|
                                            M.return_ (|
                                              Value.StructTuple
                                                "core::result::Result::Err"
                                                [ M.read (| __err |) ]
                                            |)
                                          |)
                                        |)
                                      |)))
                                ]
                              |)
                            |) in
                          let~ _ :=
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "serde::ser::SerializeTupleVariant",
                                    Ty.associated,
                                    [],
                                    "serialize_field",
                                    [ Ty.path "move_binary_format::normalized::Type" ]
                                  |),
                                  [ __serde_state; M.read (| __field0 |) ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let __val := M.copy (| γ0_0 |) in
                                    __val));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let __err := M.copy (| γ0_0 |) in
                                    M.alloc (|
                                      M.never_to_any (|
                                        M.read (|
                                          M.return_ (|
                                            Value.StructTuple
                                              "core::result::Result::Err"
                                              [ M.read (| __err |) ]
                                          |)
                                        |)
                                      |)
                                    |)))
                              ]
                            |) in
                          let~ _ :=
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "serde::ser::SerializeTupleVariant",
                                    Ty.associated,
                                    [],
                                    "serialize_field",
                                    [ Ty.path "u64" ]
                                  |),
                                  [ __serde_state; M.read (| __field1 |) ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let __val := M.copy (| γ0_0 |) in
                                    __val));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let __err := M.copy (| γ0_0 |) in
                                    M.alloc (|
                                      M.never_to_any (|
                                        M.read (|
                                          M.return_ (|
                                            Value.StructTuple
                                              "core::result::Result::Err"
                                              [ M.read (| __err |) ]
                                          |)
                                        |)
                                      |)
                                    |)))
                              ]
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::SerializeTupleVariant",
                                Ty.associated,
                                [],
                                "end",
                                []
                              |),
                              [ M.read (| __serde_state |) ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::VecLen",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "move_binary_format::normalized::Type" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 54;
                                M.read (| Value.String "VecLen" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::VecImmBorrow",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "move_binary_format::normalized::Type" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 55;
                                M.read (| Value.String "VecImmBorrow" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::VecMutBorrow",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "move_binary_format::normalized::Type" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 56;
                                M.read (| Value.String "VecMutBorrow" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::VecPushBack",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "move_binary_format::normalized::Type" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 57;
                                M.read (| Value.String "VecPushBack" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::VecPopBack",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "move_binary_format::normalized::Type" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 58;
                                M.read (| Value.String "VecPopBack" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::VecUnpack",
                              0
                            |) in
                          let γ0_1 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::VecUnpack",
                              1
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          let __field1 := M.alloc (| γ0_1 |) in
                          let~ __serde_state :=
                            M.copy (|
                              M.match_operator (|
                                M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "serde::ser::Serializer",
                                      __S,
                                      [],
                                      "serialize_tuple_variant",
                                      []
                                    |),
                                    [
                                      M.read (| __serializer |);
                                      M.read (| Value.String "Bytecode" |);
                                      Value.Integer IntegerKind.U32 59;
                                      M.read (| Value.String "VecUnpack" |);
                                      BinOp.Wrap.add (|
                                        BinOp.Wrap.add (|
                                          Value.Integer IntegerKind.Usize 0,
                                          Value.Integer IntegerKind.Usize 1
                                        |),
                                        Value.Integer IntegerKind.Usize 1
                                      |)
                                    ]
                                  |)
                                |),
                                [
                                  fun γ =>
                                    ltac:(M.monadic
                                      (let γ0_0 :=
                                        M.SubPointer.get_struct_tuple_field (|
                                          γ,
                                          "core::result::Result::Ok",
                                          0
                                        |) in
                                      let __val := M.copy (| γ0_0 |) in
                                      __val));
                                  fun γ =>
                                    ltac:(M.monadic
                                      (let γ0_0 :=
                                        M.SubPointer.get_struct_tuple_field (|
                                          γ,
                                          "core::result::Result::Err",
                                          0
                                        |) in
                                      let __err := M.copy (| γ0_0 |) in
                                      M.alloc (|
                                        M.never_to_any (|
                                          M.read (|
                                            M.return_ (|
                                              Value.StructTuple
                                                "core::result::Result::Err"
                                                [ M.read (| __err |) ]
                                            |)
                                          |)
                                        |)
                                      |)))
                                ]
                              |)
                            |) in
                          let~ _ :=
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "serde::ser::SerializeTupleVariant",
                                    Ty.associated,
                                    [],
                                    "serialize_field",
                                    [ Ty.path "move_binary_format::normalized::Type" ]
                                  |),
                                  [ __serde_state; M.read (| __field0 |) ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let __val := M.copy (| γ0_0 |) in
                                    __val));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let __err := M.copy (| γ0_0 |) in
                                    M.alloc (|
                                      M.never_to_any (|
                                        M.read (|
                                          M.return_ (|
                                            Value.StructTuple
                                              "core::result::Result::Err"
                                              [ M.read (| __err |) ]
                                          |)
                                        |)
                                      |)
                                    |)))
                              ]
                            |) in
                          let~ _ :=
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "serde::ser::SerializeTupleVariant",
                                    Ty.associated,
                                    [],
                                    "serialize_field",
                                    [ Ty.path "u64" ]
                                  |),
                                  [ __serde_state; M.read (| __field1 |) ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let __val := M.copy (| γ0_0 |) in
                                    __val));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let __err := M.copy (| γ0_0 |) in
                                    M.alloc (|
                                      M.never_to_any (|
                                        M.read (|
                                          M.return_ (|
                                            Value.StructTuple
                                              "core::result::Result::Err"
                                              [ M.read (| __err |) ]
                                          |)
                                        |)
                                      |)
                                    |)))
                              ]
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::SerializeTupleVariant",
                                Ty.associated,
                                [],
                                "end",
                                []
                              |),
                              [ M.read (| __serde_state |) ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::VecSwap",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "move_binary_format::normalized::Type" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 60;
                                M.read (| Value.String "VecSwap" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::LdU16",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "u16" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 61;
                                M.read (| Value.String "LdU16" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::LdU32",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "u32" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 62;
                                M.read (| Value.String "LdU32" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::LdU256",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "move_core_types::u256::U256" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 63;
                                M.read (| Value.String "LdU256" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::CastU16"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 64;
                                M.read (| Value.String "CastU16" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::CastU32"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 65;
                                M.read (| Value.String "CastU32" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::normalized::Bytecode::CastU256"
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_unit_variant",
                                []
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 66;
                                M.read (| Value.String "CastU256" |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::MutBorrowGlobalDeprecated",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "move_core_types::identifier::Identifier" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 67;
                                M.read (| Value.String "MutBorrowGlobalDeprecated" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::MutBorrowGlobalGenericDeprecated",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [
                                  Ty.tuple
                                    [
                                      Ty.path "move_core_types::identifier::Identifier";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ]
                                ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 68;
                                M.read (| Value.String "MutBorrowGlobalGenericDeprecated" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::ImmBorrowGlobalDeprecated",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "move_core_types::identifier::Identifier" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 69;
                                M.read (| Value.String "ImmBorrowGlobalDeprecated" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::ImmBorrowGlobalGenericDeprecated",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [
                                  Ty.tuple
                                    [
                                      Ty.path "move_core_types::identifier::Identifier";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ]
                                ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 70;
                                M.read (| Value.String "ImmBorrowGlobalGenericDeprecated" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::ExistsDeprecated",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "move_core_types::identifier::Identifier" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 71;
                                M.read (| Value.String "ExistsDeprecated" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::ExistsGenericDeprecated",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [
                                  Ty.tuple
                                    [
                                      Ty.path "move_core_types::identifier::Identifier";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ]
                                ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 72;
                                M.read (| Value.String "ExistsGenericDeprecated" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::MoveFromDeprecated",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "move_core_types::identifier::Identifier" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 73;
                                M.read (| Value.String "MoveFromDeprecated" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::MoveFromGenericDeprecated",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [
                                  Ty.tuple
                                    [
                                      Ty.path "move_core_types::identifier::Identifier";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ]
                                ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 74;
                                M.read (| Value.String "MoveFromGenericDeprecated" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::MoveToDeprecated",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [ Ty.path "move_core_types::identifier::Identifier" ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 75;
                                M.read (| Value.String "MoveToDeprecated" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::normalized::Bytecode::MoveToGenericDeprecated",
                              0
                            |) in
                          let __field0 := M.alloc (| γ0_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "serde::ser::Serializer",
                                __S,
                                [],
                                "serialize_newtype_variant",
                                [
                                  Ty.tuple
                                    [
                                      Ty.path "move_core_types::identifier::Identifier";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ]
                                ]
                              |),
                              [
                                M.read (| __serializer |);
                                M.read (| Value.String "Bytecode" |);
                                Value.Integer IntegerKind.U32 76;
                                M.read (| Value.String "MoveToGenericDeprecated" |);
                                M.read (| __field0 |)
                              ]
                            |)
                          |)))
                    ]
                  |)
                |)))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "serde::ser::Serialize"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("serialize", InstanceField.Method serialize) ].
    End Impl_serde_ser_Serialize_for_move_binary_format_normalized_Bytecode.
    Module Impl_serde_de_Deserialize_for_move_binary_format_normalized_Bytecode.
      Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Bytecode".
      
      (* Deserialize *)
      Definition deserialize (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __D ], [ __deserializer ] =>
          ltac:(M.monadic
            (let __deserializer := M.alloc (| __deserializer |) in
            M.call_closure (|
              M.get_trait_method (|
                "serde::de::Deserializer",
                __D,
                [],
                "deserialize_enum",
                [ Ty.path "move_binary_format::normalized::_'15::deserialize::__Visitor" ]
              |),
              [
                M.read (| __deserializer |);
                M.read (| Value.String "Bytecode" |);
                M.read (|
                  M.get_constant (| "move_binary_format::normalized::_'15::deserialize::VARIANTS" |)
                |);
                Value.StructRecord
                  "move_binary_format::normalized::_'15::deserialize::__Visitor"
                  [
                    ("marker", Value.StructTuple "core::marker::PhantomData" []);
                    ("lifetime", Value.StructTuple "core::marker::PhantomData" [])
                  ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "serde::de::Deserialize"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("deserialize", InstanceField.Method deserialize) ].
    End Impl_serde_de_Deserialize_for_move_binary_format_normalized_Bytecode.
    Module Impl_serde_ser_Serialize_for_move_binary_format_normalized_Module.
      Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Module".
      
      (* Serialize *)
      Definition serialize (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __S ], [ self; __serializer ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let __serializer := M.alloc (| __serializer |) in
            M.catch_return (|
              ltac:(M.monadic
                (M.read (|
                  let~ __serde_state :=
                    M.copy (|
                      M.match_operator (|
                        M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "serde::ser::Serializer",
                              __S,
                              [],
                              "serialize_struct",
                              []
                            |),
                            [
                              M.read (| __serializer |);
                              M.read (| Value.String "Module" |);
                              BinOp.Wrap.add (|
                                BinOp.Wrap.add (|
                                  BinOp.Wrap.add (|
                                    BinOp.Wrap.add (|
                                      BinOp.Wrap.add (|
                                        BinOp.Wrap.add (|
                                          BinOp.Wrap.add (|
                                            BinOp.Wrap.add (|
                                              M.rust_cast (Value.Bool false),
                                              Value.Integer IntegerKind.Usize 1
                                            |),
                                            Value.Integer IntegerKind.Usize 1
                                          |),
                                          Value.Integer IntegerKind.Usize 1
                                        |),
                                        Value.Integer IntegerKind.Usize 1
                                      |),
                                      Value.Integer IntegerKind.Usize 1
                                    |),
                                    Value.Integer IntegerKind.Usize 1
                                  |),
                                  Value.Integer IntegerKind.Usize 1
                                |),
                                Value.Integer IntegerKind.Usize 1
                              |)
                            ]
                          |)
                        |),
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ,
                                  "core::result::Result::Ok",
                                  0
                                |) in
                              let __val := M.copy (| γ0_0 |) in
                              __val));
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ,
                                  "core::result::Result::Err",
                                  0
                                |) in
                              let __err := M.copy (| γ0_0 |) in
                              M.alloc (|
                                M.never_to_any (|
                                  M.read (|
                                    M.return_ (|
                                      Value.StructTuple
                                        "core::result::Result::Err"
                                        [ M.read (| __err |) ]
                                    |)
                                  |)
                                |)
                              |)))
                        ]
                      |)
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [ Ty.path "u32" ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "file_format_version" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Module",
                              "file_format_version"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [ Ty.path "move_core_types::account_address::AccountAddress" ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "address" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Module",
                              "address"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [ Ty.path "move_core_types::identifier::Identifier" ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "name" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Module",
                              "name"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [
                              Ty.apply
                                (Ty.path "alloc::vec::Vec")
                                []
                                [
                                  Ty.path "move_core_types::language_storage::ModuleId";
                                  Ty.path "alloc::alloc::Global"
                                ]
                            ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "dependencies" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Module",
                              "dependencies"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [
                              Ty.apply
                                (Ty.path "alloc::vec::Vec")
                                []
                                [
                                  Ty.path "move_core_types::language_storage::ModuleId";
                                  Ty.path "alloc::alloc::Global"
                                ]
                            ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "friends" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Module",
                              "friends"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [
                              Ty.apply
                                (Ty.path "alloc::collections::btree::map::BTreeMap")
                                []
                                [
                                  Ty.path "move_core_types::identifier::Identifier";
                                  Ty.path "move_binary_format::normalized::Struct";
                                  Ty.path "alloc::alloc::Global"
                                ]
                            ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "structs" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Module",
                              "structs"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [
                              Ty.apply
                                (Ty.path "alloc::collections::btree::map::BTreeMap")
                                []
                                [
                                  Ty.path "move_core_types::identifier::Identifier";
                                  Ty.path "move_binary_format::normalized::Function";
                                  Ty.path "alloc::alloc::Global"
                                ]
                            ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "functions" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Module",
                              "functions"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "serde::ser::SerializeStruct",
                            Ty.associated,
                            [],
                            "serialize_field",
                            [
                              Ty.apply
                                (Ty.path "alloc::vec::Vec")
                                []
                                [
                                  Ty.path "move_binary_format::normalized::Constant";
                                  Ty.path "alloc::alloc::Global"
                                ]
                            ]
                          |),
                          [
                            __serde_state;
                            M.read (| Value.String "constants" |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Module",
                              "constants"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Ok",
                                0
                              |) in
                            let __val := M.copy (| γ0_0 |) in
                            __val));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::result::Result::Err",
                                0
                              |) in
                            let __err := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::result::Result::Err"
                                      [ M.read (| __err |) ]
                                  |)
                                |)
                              |)
                            |)))
                      ]
                    |) in
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "serde::ser::SerializeStruct",
                        Ty.associated,
                        [],
                        "end",
                        []
                      |),
                      [ M.read (| __serde_state |) ]
                    |)
                  |)
                |)))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "serde::ser::Serialize"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("serialize", InstanceField.Method serialize) ].
    End Impl_serde_ser_Serialize_for_move_binary_format_normalized_Module.
    Module Impl_serde_de_Deserialize_for_move_binary_format_normalized_Module.
      Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Module".
      
      (* Deserialize *)
      Definition deserialize (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __D ], [ __deserializer ] =>
          ltac:(M.monadic
            (let __deserializer := M.alloc (| __deserializer |) in
            M.call_closure (|
              M.get_trait_method (|
                "serde::de::Deserializer",
                __D,
                [],
                "deserialize_struct",
                [ Ty.path "move_binary_format::normalized::_'17::deserialize::__Visitor" ]
              |),
              [
                M.read (| __deserializer |);
                M.read (| Value.String "Module" |);
                M.read (|
                  M.get_constant (| "move_binary_format::normalized::_'17::deserialize::FIELDS" |)
                |);
                Value.StructRecord
                  "move_binary_format::normalized::_'17::deserialize::__Visitor"
                  [
                    ("marker", Value.StructTuple "core::marker::PhantomData" []);
                    ("lifetime", Value.StructTuple "core::marker::PhantomData" [])
                  ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "serde::de::Deserialize"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("deserialize", InstanceField.Method deserialize) ].
    End Impl_serde_de_Deserialize_for_move_binary_format_normalized_Module.
  End underscore.
  
  
  (* StructRecord
    {
      name := "Field";
      const_params := [];
      ty_params := [];
      fields :=
        [
          ("name", Ty.path "move_core_types::identifier::Identifier");
          ("type_", Ty.path "move_binary_format::normalized::Type")
        ];
    } *)
  
  Module Impl_core_clone_Clone_for_move_binary_format_normalized_Field.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Field".
    
    (* Clone *)
    Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          Value.StructRecord
            "move_binary_format::normalized::Field"
            [
              ("name",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.path "move_core_types::identifier::Identifier",
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Field",
                      "name"
                    |)
                  ]
                |));
              ("type_",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.path "move_binary_format::normalized::Type",
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Field",
                      "type_"
                    |)
                  ]
                |))
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::clone::Clone"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("clone", InstanceField.Method clone) ].
  End Impl_core_clone_Clone_for_move_binary_format_normalized_Field.
  
  Module Impl_core_fmt_Debug_for_move_binary_format_normalized_Field.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Field".
    
    (* Debug *)
    Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; f ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let f := M.alloc (| f |) in
          M.call_closure (|
            M.get_associated_function (|
              Ty.path "core::fmt::Formatter",
              "debug_struct_field2_finish",
              []
            |),
            [
              M.read (| f |);
              M.read (| Value.String "Field" |);
              M.read (| Value.String "name" |);
              M.SubPointer.get_struct_record_field (|
                M.read (| self |),
                "move_binary_format::normalized::Field",
                "name"
              |);
              M.read (| Value.String "type_" |);
              M.alloc (|
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "move_binary_format::normalized::Field",
                  "type_"
                |)
              |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::fmt::Debug"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
  End Impl_core_fmt_Debug_for_move_binary_format_normalized_Field.
  
  Module Impl_core_cmp_Eq_for_move_binary_format_normalized_Field.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Field".
    
    (* Eq *)
    Definition assert_receiver_is_total_eq
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.read (|
            M.match_operator (|
              Value.DeclaredButUndefined,
              [
                fun γ =>
                  ltac:(M.monadic
                    (M.match_operator (|
                      Value.DeclaredButUndefined,
                      [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::Eq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *)
        [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ].
  End Impl_core_cmp_Eq_for_move_binary_format_normalized_Field.
  
  Module Impl_core_marker_StructuralPartialEq_for_move_binary_format_normalized_Field.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Field".
    
    Axiom Implements :
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_move_binary_format_normalized_Field.
  
  Module Impl_core_cmp_PartialEq_for_move_binary_format_normalized_Field.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Field".
    
    (* PartialEq *)
    Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.and (|
            M.call_closure (|
              M.get_trait_method (|
                "core::cmp::PartialEq",
                Ty.path "move_core_types::identifier::Identifier",
                [ Ty.path "move_core_types::identifier::Identifier" ],
                "eq",
                []
              |),
              [
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "move_binary_format::normalized::Field",
                  "name"
                |);
                M.SubPointer.get_struct_record_field (|
                  M.read (| other |),
                  "move_binary_format::normalized::Field",
                  "name"
                |)
              ]
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (|
                  "core::cmp::PartialEq",
                  Ty.path "move_binary_format::normalized::Type",
                  [ Ty.path "move_binary_format::normalized::Type" ],
                  "eq",
                  []
                |),
                [
                  M.SubPointer.get_struct_record_field (|
                    M.read (| self |),
                    "move_binary_format::normalized::Field",
                    "type_"
                  |);
                  M.SubPointer.get_struct_record_field (|
                    M.read (| other |),
                    "move_binary_format::normalized::Field",
                    "type_"
                  |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::PartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("eq", InstanceField.Method eq) ].
  End Impl_core_cmp_PartialEq_for_move_binary_format_normalized_Field.
  
  
  
  Module Impl_core_cmp_Ord_for_move_binary_format_normalized_Field.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Field".
    
    (* Ord *)
    Definition cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (|
                    "core::cmp::Ord",
                    Ty.path "move_core_types::identifier::Identifier",
                    [],
                    "cmp",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Field",
                      "name"
                    |);
                    M.SubPointer.get_struct_record_field (|
                      M.read (| other |),
                      "move_binary_format::normalized::Field",
                      "name"
                    |)
                  ]
                |)
              |),
              [
                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",
                          Ty.path "move_binary_format::normalized::Type",
                          [],
                          "cmp",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| self |),
                            "move_binary_format::normalized::Field",
                            "type_"
                          |);
                          M.SubPointer.get_struct_record_field (|
                            M.read (| other |),
                            "move_binary_format::normalized::Field",
                            "type_"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let cmp := M.copy (| γ |) in
                    cmp))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::Ord"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("cmp", InstanceField.Method cmp) ].
  End Impl_core_cmp_Ord_for_move_binary_format_normalized_Field.
  
  Module Impl_core_cmp_PartialOrd_for_move_binary_format_normalized_Field.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Field".
    
    (* PartialOrd *)
    Definition partial_cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (|
                    "core::cmp::PartialOrd",
                    Ty.path "move_core_types::identifier::Identifier",
                    [ Ty.path "move_core_types::identifier::Identifier" ],
                    "partial_cmp",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Field",
                      "name"
                    |);
                    M.SubPointer.get_struct_record_field (|
                      M.read (| other |),
                      "move_binary_format::normalized::Field",
                      "name"
                    |)
                  ]
                |)
              |),
              [
                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",
                          Ty.path "move_binary_format::normalized::Type",
                          [ Ty.path "move_binary_format::normalized::Type" ],
                          "partial_cmp",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| self |),
                            "move_binary_format::normalized::Field",
                            "type_"
                          |);
                          M.SubPointer.get_struct_record_field (|
                            M.read (| other |),
                            "move_binary_format::normalized::Field",
                            "type_"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let cmp := M.copy (| γ |) in
                    cmp))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::PartialOrd"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("partial_cmp", InstanceField.Method partial_cmp) ].
  End Impl_core_cmp_PartialOrd_for_move_binary_format_normalized_Field.
  
  (* StructRecord
    {
      name := "Constant";
      const_params := [];
      ty_params := [];
      fields :=
        [
          ("type_", Ty.path "move_binary_format::normalized::Type");
          ("data",
            Ty.apply
              (Ty.path "alloc::vec::Vec")
              []
              [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ])
        ];
    } *)
  
  Module Impl_core_clone_Clone_for_move_binary_format_normalized_Constant.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Constant".
    
    (* Clone *)
    Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          Value.StructRecord
            "move_binary_format::normalized::Constant"
            [
              ("type_",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.path "move_binary_format::normalized::Type",
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Constant",
                      "type_"
                    |)
                  ]
                |));
              ("data",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ],
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Constant",
                      "data"
                    |)
                  ]
                |))
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::clone::Clone"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("clone", InstanceField.Method clone) ].
  End Impl_core_clone_Clone_for_move_binary_format_normalized_Constant.
  
  Module Impl_core_fmt_Debug_for_move_binary_format_normalized_Constant.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Constant".
    
    (* Debug *)
    Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; f ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let f := M.alloc (| f |) in
          M.call_closure (|
            M.get_associated_function (|
              Ty.path "core::fmt::Formatter",
              "debug_struct_field2_finish",
              []
            |),
            [
              M.read (| f |);
              M.read (| Value.String "Constant" |);
              M.read (| Value.String "type_" |);
              M.SubPointer.get_struct_record_field (|
                M.read (| self |),
                "move_binary_format::normalized::Constant",
                "type_"
              |);
              M.read (| Value.String "data" |);
              M.alloc (|
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "move_binary_format::normalized::Constant",
                  "data"
                |)
              |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::fmt::Debug"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
  End Impl_core_fmt_Debug_for_move_binary_format_normalized_Constant.
  
  Module Impl_core_cmp_Eq_for_move_binary_format_normalized_Constant.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Constant".
    
    (* Eq *)
    Definition assert_receiver_is_total_eq
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.read (|
            M.match_operator (|
              Value.DeclaredButUndefined,
              [
                fun γ =>
                  ltac:(M.monadic
                    (M.match_operator (|
                      Value.DeclaredButUndefined,
                      [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::Eq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *)
        [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ].
  End Impl_core_cmp_Eq_for_move_binary_format_normalized_Constant.
  
  Module Impl_core_marker_StructuralPartialEq_for_move_binary_format_normalized_Constant.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Constant".
    
    Axiom Implements :
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_move_binary_format_normalized_Constant.
  
  Module Impl_core_cmp_PartialEq_for_move_binary_format_normalized_Constant.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Constant".
    
    (* PartialEq *)
    Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.and (|
            M.call_closure (|
              M.get_trait_method (|
                "core::cmp::PartialEq",
                Ty.path "move_binary_format::normalized::Type",
                [ Ty.path "move_binary_format::normalized::Type" ],
                "eq",
                []
              |),
              [
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "move_binary_format::normalized::Constant",
                  "type_"
                |);
                M.SubPointer.get_struct_record_field (|
                  M.read (| other |),
                  "move_binary_format::normalized::Constant",
                  "type_"
                |)
              ]
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (|
                  "core::cmp::PartialEq",
                  Ty.apply
                    (Ty.path "alloc::vec::Vec")
                    []
                    [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ],
                  [
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ]
                  ],
                  "eq",
                  []
                |),
                [
                  M.SubPointer.get_struct_record_field (|
                    M.read (| self |),
                    "move_binary_format::normalized::Constant",
                    "data"
                  |);
                  M.SubPointer.get_struct_record_field (|
                    M.read (| other |),
                    "move_binary_format::normalized::Constant",
                    "data"
                  |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::PartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("eq", InstanceField.Method eq) ].
  End Impl_core_cmp_PartialEq_for_move_binary_format_normalized_Constant.
  
  
  
  Module Impl_core_cmp_Ord_for_move_binary_format_normalized_Constant.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Constant".
    
    (* Ord *)
    Definition cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (|
                    "core::cmp::Ord",
                    Ty.path "move_binary_format::normalized::Type",
                    [],
                    "cmp",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Constant",
                      "type_"
                    |);
                    M.SubPointer.get_struct_record_field (|
                      M.read (| other |),
                      "move_binary_format::normalized::Constant",
                      "type_"
                    |)
                  ]
                |)
              |),
              [
                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",
                          Ty.apply
                            (Ty.path "alloc::vec::Vec")
                            []
                            [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ],
                          [],
                          "cmp",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| self |),
                            "move_binary_format::normalized::Constant",
                            "data"
                          |);
                          M.SubPointer.get_struct_record_field (|
                            M.read (| other |),
                            "move_binary_format::normalized::Constant",
                            "data"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let cmp := M.copy (| γ |) in
                    cmp))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::Ord"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("cmp", InstanceField.Method cmp) ].
  End Impl_core_cmp_Ord_for_move_binary_format_normalized_Constant.
  
  Module Impl_core_cmp_PartialOrd_for_move_binary_format_normalized_Constant.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Constant".
    
    (* PartialOrd *)
    Definition partial_cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (|
                    "core::cmp::PartialOrd",
                    Ty.path "move_binary_format::normalized::Type",
                    [ Ty.path "move_binary_format::normalized::Type" ],
                    "partial_cmp",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Constant",
                      "type_"
                    |);
                    M.SubPointer.get_struct_record_field (|
                      M.read (| other |),
                      "move_binary_format::normalized::Constant",
                      "type_"
                    |)
                  ]
                |)
              |),
              [
                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",
                          Ty.apply
                            (Ty.path "alloc::vec::Vec")
                            []
                            [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ],
                          [
                            Ty.apply
                              (Ty.path "alloc::vec::Vec")
                              []
                              [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ]
                          ],
                          "partial_cmp",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| self |),
                            "move_binary_format::normalized::Constant",
                            "data"
                          |);
                          M.SubPointer.get_struct_record_field (|
                            M.read (| other |),
                            "move_binary_format::normalized::Constant",
                            "data"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let cmp := M.copy (| γ |) in
                    cmp))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::PartialOrd"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("partial_cmp", InstanceField.Method partial_cmp) ].
  End Impl_core_cmp_PartialOrd_for_move_binary_format_normalized_Constant.
  
  (* StructRecord
    {
      name := "Struct";
      const_params := [];
      ty_params := [];
      fields :=
        [
          ("abilities", Ty.path "move_binary_format::file_format::AbilitySet");
          ("type_parameters",
            Ty.apply
              (Ty.path "alloc::vec::Vec")
              []
              [
                Ty.path "move_binary_format::file_format::StructTypeParameter";
                Ty.path "alloc::alloc::Global"
              ]);
          ("fields",
            Ty.apply
              (Ty.path "alloc::vec::Vec")
              []
              [ Ty.path "move_binary_format::normalized::Field"; Ty.path "alloc::alloc::Global" ])
        ];
    } *)
  
  Module Impl_core_clone_Clone_for_move_binary_format_normalized_Struct.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Struct".
    
    (* Clone *)
    Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          Value.StructRecord
            "move_binary_format::normalized::Struct"
            [
              ("abilities",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.path "move_binary_format::file_format::AbilitySet",
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Struct",
                      "abilities"
                    |)
                  ]
                |));
              ("type_parameters",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::file_format::StructTypeParameter";
                        Ty.path "alloc::alloc::Global"
                      ],
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Struct",
                      "type_parameters"
                    |)
                  ]
                |));
              ("fields",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::normalized::Field";
                        Ty.path "alloc::alloc::Global"
                      ],
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Struct",
                      "fields"
                    |)
                  ]
                |))
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::clone::Clone"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("clone", InstanceField.Method clone) ].
  End Impl_core_clone_Clone_for_move_binary_format_normalized_Struct.
  
  Module Impl_core_fmt_Debug_for_move_binary_format_normalized_Struct.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Struct".
    
    (* Debug *)
    Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; f ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let f := M.alloc (| f |) in
          M.call_closure (|
            M.get_associated_function (|
              Ty.path "core::fmt::Formatter",
              "debug_struct_field3_finish",
              []
            |),
            [
              M.read (| f |);
              M.read (| Value.String "Struct" |);
              M.read (| Value.String "abilities" |);
              M.SubPointer.get_struct_record_field (|
                M.read (| self |),
                "move_binary_format::normalized::Struct",
                "abilities"
              |);
              M.read (| Value.String "type_parameters" |);
              M.SubPointer.get_struct_record_field (|
                M.read (| self |),
                "move_binary_format::normalized::Struct",
                "type_parameters"
              |);
              M.read (| Value.String "fields" |);
              M.alloc (|
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "move_binary_format::normalized::Struct",
                  "fields"
                |)
              |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::fmt::Debug"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
  End Impl_core_fmt_Debug_for_move_binary_format_normalized_Struct.
  
  Module Impl_core_cmp_Eq_for_move_binary_format_normalized_Struct.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Struct".
    
    (* Eq *)
    Definition assert_receiver_is_total_eq
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.read (|
            M.match_operator (|
              Value.DeclaredButUndefined,
              [
                fun γ =>
                  ltac:(M.monadic
                    (M.match_operator (|
                      Value.DeclaredButUndefined,
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              Value.DeclaredButUndefined,
                              [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::Eq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *)
        [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ].
  End Impl_core_cmp_Eq_for_move_binary_format_normalized_Struct.
  
  Module Impl_core_marker_StructuralPartialEq_for_move_binary_format_normalized_Struct.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Struct".
    
    Axiom Implements :
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_move_binary_format_normalized_Struct.
  
  Module Impl_core_cmp_PartialEq_for_move_binary_format_normalized_Struct.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Struct".
    
    (* PartialEq *)
    Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.and (|
            LogicalOp.and (|
              M.call_closure (|
                M.get_trait_method (|
                  "core::cmp::PartialEq",
                  Ty.path "move_binary_format::file_format::AbilitySet",
                  [ Ty.path "move_binary_format::file_format::AbilitySet" ],
                  "eq",
                  []
                |),
                [
                  M.SubPointer.get_struct_record_field (|
                    M.read (| self |),
                    "move_binary_format::normalized::Struct",
                    "abilities"
                  |);
                  M.SubPointer.get_struct_record_field (|
                    M.read (| other |),
                    "move_binary_format::normalized::Struct",
                    "abilities"
                  |)
                ]
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (|
                    "core::cmp::PartialEq",
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::file_format::StructTypeParameter";
                        Ty.path "alloc::alloc::Global"
                      ],
                    [
                      Ty.apply
                        (Ty.path "alloc::vec::Vec")
                        []
                        [
                          Ty.path "move_binary_format::file_format::StructTypeParameter";
                          Ty.path "alloc::alloc::Global"
                        ]
                    ],
                    "eq",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Struct",
                      "type_parameters"
                    |);
                    M.SubPointer.get_struct_record_field (|
                      M.read (| other |),
                      "move_binary_format::normalized::Struct",
                      "type_parameters"
                    |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (|
                  "core::cmp::PartialEq",
                  Ty.apply
                    (Ty.path "alloc::vec::Vec")
                    []
                    [
                      Ty.path "move_binary_format::normalized::Field";
                      Ty.path "alloc::alloc::Global"
                    ],
                  [
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::normalized::Field";
                        Ty.path "alloc::alloc::Global"
                      ]
                  ],
                  "eq",
                  []
                |),
                [
                  M.SubPointer.get_struct_record_field (|
                    M.read (| self |),
                    "move_binary_format::normalized::Struct",
                    "fields"
                  |);
                  M.SubPointer.get_struct_record_field (|
                    M.read (| other |),
                    "move_binary_format::normalized::Struct",
                    "fields"
                  |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::PartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("eq", InstanceField.Method eq) ].
  End Impl_core_cmp_PartialEq_for_move_binary_format_normalized_Struct.
  
  
  
  Module Impl_core_cmp_Ord_for_move_binary_format_normalized_Struct.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Struct".
    
    (* Ord *)
    Definition cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (|
                    "core::cmp::Ord",
                    Ty.path "move_binary_format::file_format::AbilitySet",
                    [],
                    "cmp",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Struct",
                      "abilities"
                    |);
                    M.SubPointer.get_struct_record_field (|
                      M.read (| other |),
                      "move_binary_format::normalized::Struct",
                      "abilities"
                    |)
                  ]
                |)
              |),
              [
                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",
                            Ty.apply
                              (Ty.path "alloc::vec::Vec")
                              []
                              [
                                Ty.path "move_binary_format::file_format::StructTypeParameter";
                                Ty.path "alloc::alloc::Global"
                              ],
                            [],
                            "cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Struct",
                              "type_parameters"
                            |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| other |),
                              "move_binary_format::normalized::Struct",
                              "type_parameters"
                            |)
                          ]
                        |)
                      |),
                      [
                        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",
                                  Ty.apply
                                    (Ty.path "alloc::vec::Vec")
                                    []
                                    [
                                      Ty.path "move_binary_format::normalized::Field";
                                      Ty.path "alloc::alloc::Global"
                                    ],
                                  [],
                                  "cmp",
                                  []
                                |),
                                [
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| self |),
                                    "move_binary_format::normalized::Struct",
                                    "fields"
                                  |);
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| other |),
                                    "move_binary_format::normalized::Struct",
                                    "fields"
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let cmp := M.copy (| γ |) in
                            cmp))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let cmp := M.copy (| γ |) in
                    cmp))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::Ord"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("cmp", InstanceField.Method cmp) ].
  End Impl_core_cmp_Ord_for_move_binary_format_normalized_Struct.
  
  Module Impl_core_cmp_PartialOrd_for_move_binary_format_normalized_Struct.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Struct".
    
    (* PartialOrd *)
    Definition partial_cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (|
                    "core::cmp::PartialOrd",
                    Ty.path "move_binary_format::file_format::AbilitySet",
                    [ Ty.path "move_binary_format::file_format::AbilitySet" ],
                    "partial_cmp",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Struct",
                      "abilities"
                    |);
                    M.SubPointer.get_struct_record_field (|
                      M.read (| other |),
                      "move_binary_format::normalized::Struct",
                      "abilities"
                    |)
                  ]
                |)
              |),
              [
                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",
                            Ty.apply
                              (Ty.path "alloc::vec::Vec")
                              []
                              [
                                Ty.path "move_binary_format::file_format::StructTypeParameter";
                                Ty.path "alloc::alloc::Global"
                              ],
                            [
                              Ty.apply
                                (Ty.path "alloc::vec::Vec")
                                []
                                [
                                  Ty.path "move_binary_format::file_format::StructTypeParameter";
                                  Ty.path "alloc::alloc::Global"
                                ]
                            ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Struct",
                              "type_parameters"
                            |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| other |),
                              "move_binary_format::normalized::Struct",
                              "type_parameters"
                            |)
                          ]
                        |)
                      |),
                      [
                        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",
                                  Ty.apply
                                    (Ty.path "alloc::vec::Vec")
                                    []
                                    [
                                      Ty.path "move_binary_format::normalized::Field";
                                      Ty.path "alloc::alloc::Global"
                                    ],
                                  [
                                    Ty.apply
                                      (Ty.path "alloc::vec::Vec")
                                      []
                                      [
                                        Ty.path "move_binary_format::normalized::Field";
                                        Ty.path "alloc::alloc::Global"
                                      ]
                                  ],
                                  "partial_cmp",
                                  []
                                |),
                                [
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| self |),
                                    "move_binary_format::normalized::Struct",
                                    "fields"
                                  |);
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| other |),
                                    "move_binary_format::normalized::Struct",
                                    "fields"
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let cmp := M.copy (| γ |) in
                            cmp))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let cmp := M.copy (| γ |) in
                    cmp))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::PartialOrd"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("partial_cmp", InstanceField.Method partial_cmp) ].
  End Impl_core_cmp_PartialOrd_for_move_binary_format_normalized_Struct.
  
  (* StructRecord
    {
      name := "Function";
      const_params := [];
      ty_params := [];
      fields :=
        [
          ("visibility", Ty.path "move_binary_format::file_format::Visibility");
          ("is_entry", Ty.path "bool");
          ("type_parameters",
            Ty.apply
              (Ty.path "alloc::vec::Vec")
              []
              [
                Ty.path "move_binary_format::file_format::AbilitySet";
                Ty.path "alloc::alloc::Global"
              ]);
          ("parameters",
            Ty.apply
              (Ty.path "alloc::vec::Vec")
              []
              [ Ty.path "move_binary_format::normalized::Type"; Ty.path "alloc::alloc::Global" ]);
          ("return_",
            Ty.apply
              (Ty.path "alloc::vec::Vec")
              []
              [ Ty.path "move_binary_format::normalized::Type"; Ty.path "alloc::alloc::Global" ]);
          ("code",
            Ty.apply
              (Ty.path "alloc::vec::Vec")
              []
              [ Ty.path "move_binary_format::normalized::Bytecode"; Ty.path "alloc::alloc::Global"
              ])
        ];
    } *)
  
  Module Impl_core_clone_Clone_for_move_binary_format_normalized_Function.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Function".
    
    (* Clone *)
    Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          Value.StructRecord
            "move_binary_format::normalized::Function"
            [
              ("visibility",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.path "move_binary_format::file_format::Visibility",
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Function",
                      "visibility"
                    |)
                  ]
                |));
              ("is_entry",
                M.call_closure (|
                  M.get_trait_method (| "core::clone::Clone", Ty.path "bool", [], "clone", [] |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Function",
                      "is_entry"
                    |)
                  ]
                |));
              ("type_parameters",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::file_format::AbilitySet";
                        Ty.path "alloc::alloc::Global"
                      ],
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Function",
                      "type_parameters"
                    |)
                  ]
                |));
              ("parameters",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::normalized::Type";
                        Ty.path "alloc::alloc::Global"
                      ],
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Function",
                      "parameters"
                    |)
                  ]
                |));
              ("return_",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::normalized::Type";
                        Ty.path "alloc::alloc::Global"
                      ],
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Function",
                      "return_"
                    |)
                  ]
                |));
              ("code",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::normalized::Bytecode";
                        Ty.path "alloc::alloc::Global"
                      ],
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Function",
                      "code"
                    |)
                  ]
                |))
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::clone::Clone"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("clone", InstanceField.Method clone) ].
  End Impl_core_clone_Clone_for_move_binary_format_normalized_Function.
  
  Module Impl_core_fmt_Debug_for_move_binary_format_normalized_Function.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Function".
    
    (* Debug *)
    Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; f ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let f := M.alloc (| f |) in
          M.read (|
            let~ names :=
              M.alloc (|
                M.alloc (|
                  Value.Array
                    [
                      M.read (| Value.String "visibility" |);
                      M.read (| Value.String "is_entry" |);
                      M.read (| Value.String "type_parameters" |);
                      M.read (| Value.String "parameters" |);
                      M.read (| Value.String "return_" |);
                      M.read (| Value.String "code" |)
                    ]
                |)
              |) in
            let~ values :=
              M.alloc (|
                M.alloc (|
                  Value.Array
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "move_binary_format::normalized::Function",
                        "visibility"
                      |);
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "move_binary_format::normalized::Function",
                        "is_entry"
                      |);
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "move_binary_format::normalized::Function",
                        "type_parameters"
                      |);
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "move_binary_format::normalized::Function",
                        "parameters"
                      |);
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "move_binary_format::normalized::Function",
                        "return_"
                      |);
                      M.alloc (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "move_binary_format::normalized::Function",
                          "code"
                        |)
                      |)
                    ]
                |)
              |) in
            M.alloc (|
              M.call_closure (|
                M.get_associated_function (|
                  Ty.path "core::fmt::Formatter",
                  "debug_struct_fields_finish",
                  []
                |),
                [
                  M.read (| f |);
                  M.read (| Value.String "Function" |);
                  M.read (| names |);
                  M.read (| values |)
                ]
              |)
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::fmt::Debug"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
  End Impl_core_fmt_Debug_for_move_binary_format_normalized_Function.
  
  Module Impl_core_cmp_Ord_for_move_binary_format_normalized_Function.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Function".
    
    (* Ord *)
    Definition cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (|
                    "core::cmp::Ord",
                    Ty.path "move_binary_format::file_format::Visibility",
                    [],
                    "cmp",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Function",
                      "visibility"
                    |);
                    M.SubPointer.get_struct_record_field (|
                      M.read (| other |),
                      "move_binary_format::normalized::Function",
                      "visibility"
                    |)
                  ]
                |)
              |),
              [
                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", Ty.path "bool", [], "cmp", [] |),
                          [
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Function",
                              "is_entry"
                            |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| other |),
                              "move_binary_format::normalized::Function",
                              "is_entry"
                            |)
                          ]
                        |)
                      |),
                      [
                        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",
                                    Ty.apply
                                      (Ty.path "alloc::vec::Vec")
                                      []
                                      [
                                        Ty.path "move_binary_format::file_format::AbilitySet";
                                        Ty.path "alloc::alloc::Global"
                                      ],
                                    [],
                                    "cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| self |),
                                      "move_binary_format::normalized::Function",
                                      "type_parameters"
                                    |);
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| other |),
                                      "move_binary_format::normalized::Function",
                                      "type_parameters"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                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",
                                            Ty.apply
                                              (Ty.path "alloc::vec::Vec")
                                              []
                                              [
                                                Ty.path "move_binary_format::normalized::Type";
                                                Ty.path "alloc::alloc::Global"
                                              ],
                                            [],
                                            "cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_struct_record_field (|
                                              M.read (| self |),
                                              "move_binary_format::normalized::Function",
                                              "parameters"
                                            |);
                                            M.SubPointer.get_struct_record_field (|
                                              M.read (| other |),
                                              "move_binary_format::normalized::Function",
                                              "parameters"
                                            |)
                                          ]
                                        |)
                                      |),
                                      [
                                        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",
                                                    Ty.apply
                                                      (Ty.path "alloc::vec::Vec")
                                                      []
                                                      [
                                                        Ty.path
                                                          "move_binary_format::normalized::Type";
                                                        Ty.path "alloc::alloc::Global"
                                                      ],
                                                    [],
                                                    "cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_struct_record_field (|
                                                      M.read (| self |),
                                                      "move_binary_format::normalized::Function",
                                                      "return_"
                                                    |);
                                                    M.SubPointer.get_struct_record_field (|
                                                      M.read (| other |),
                                                      "move_binary_format::normalized::Function",
                                                      "return_"
                                                    |)
                                                  ]
                                                |)
                                              |),
                                              [
                                                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",
                                                          Ty.apply
                                                            (Ty.path "alloc::vec::Vec")
                                                            []
                                                            [
                                                              Ty.path
                                                                "move_binary_format::normalized::Bytecode";
                                                              Ty.path "alloc::alloc::Global"
                                                            ],
                                                          [],
                                                          "cmp",
                                                          []
                                                        |),
                                                        [
                                                          M.SubPointer.get_struct_record_field (|
                                                            M.read (| self |),
                                                            "move_binary_format::normalized::Function",
                                                            "code"
                                                          |);
                                                          M.SubPointer.get_struct_record_field (|
                                                            M.read (| other |),
                                                            "move_binary_format::normalized::Function",
                                                            "code"
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let cmp := M.copy (| γ |) in
                                                    cmp))
                                              ]
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let cmp := M.copy (| γ |) in
                                            cmp))
                                      ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let cmp := M.copy (| γ |) in
                                    cmp))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let cmp := M.copy (| γ |) in
                            cmp))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let cmp := M.copy (| γ |) in
                    cmp))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::Ord"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("cmp", InstanceField.Method cmp) ].
  End Impl_core_cmp_Ord_for_move_binary_format_normalized_Function.
  
  Module Impl_core_cmp_PartialOrd_for_move_binary_format_normalized_Function.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Function".
    
    (* PartialOrd *)
    Definition partial_cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (|
                    "core::cmp::PartialOrd",
                    Ty.path "move_binary_format::file_format::Visibility",
                    [ Ty.path "move_binary_format::file_format::Visibility" ],
                    "partial_cmp",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Function",
                      "visibility"
                    |);
                    M.SubPointer.get_struct_record_field (|
                      M.read (| other |),
                      "move_binary_format::normalized::Function",
                      "visibility"
                    |)
                  ]
                |)
              |),
              [
                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",
                            Ty.path "bool",
                            [ Ty.path "bool" ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Function",
                              "is_entry"
                            |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| other |),
                              "move_binary_format::normalized::Function",
                              "is_entry"
                            |)
                          ]
                        |)
                      |),
                      [
                        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",
                                    Ty.apply
                                      (Ty.path "alloc::vec::Vec")
                                      []
                                      [
                                        Ty.path "move_binary_format::file_format::AbilitySet";
                                        Ty.path "alloc::alloc::Global"
                                      ],
                                    [
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::file_format::AbilitySet";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| self |),
                                      "move_binary_format::normalized::Function",
                                      "type_parameters"
                                    |);
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| other |),
                                      "move_binary_format::normalized::Function",
                                      "type_parameters"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                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",
                                            Ty.apply
                                              (Ty.path "alloc::vec::Vec")
                                              []
                                              [
                                                Ty.path "move_binary_format::normalized::Type";
                                                Ty.path "alloc::alloc::Global"
                                              ],
                                            [
                                              Ty.apply
                                                (Ty.path "alloc::vec::Vec")
                                                []
                                                [
                                                  Ty.path "move_binary_format::normalized::Type";
                                                  Ty.path "alloc::alloc::Global"
                                                ]
                                            ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_struct_record_field (|
                                              M.read (| self |),
                                              "move_binary_format::normalized::Function",
                                              "parameters"
                                            |);
                                            M.SubPointer.get_struct_record_field (|
                                              M.read (| other |),
                                              "move_binary_format::normalized::Function",
                                              "parameters"
                                            |)
                                          ]
                                        |)
                                      |),
                                      [
                                        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",
                                                    Ty.apply
                                                      (Ty.path "alloc::vec::Vec")
                                                      []
                                                      [
                                                        Ty.path
                                                          "move_binary_format::normalized::Type";
                                                        Ty.path "alloc::alloc::Global"
                                                      ],
                                                    [
                                                      Ty.apply
                                                        (Ty.path "alloc::vec::Vec")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_binary_format::normalized::Type";
                                                          Ty.path "alloc::alloc::Global"
                                                        ]
                                                    ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_struct_record_field (|
                                                      M.read (| self |),
                                                      "move_binary_format::normalized::Function",
                                                      "return_"
                                                    |);
                                                    M.SubPointer.get_struct_record_field (|
                                                      M.read (| other |),
                                                      "move_binary_format::normalized::Function",
                                                      "return_"
                                                    |)
                                                  ]
                                                |)
                                              |),
                                              [
                                                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",
                                                          Ty.apply
                                                            (Ty.path "alloc::vec::Vec")
                                                            []
                                                            [
                                                              Ty.path
                                                                "move_binary_format::normalized::Bytecode";
                                                              Ty.path "alloc::alloc::Global"
                                                            ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "alloc::vec::Vec")
                                                              []
                                                              [
                                                                Ty.path
                                                                  "move_binary_format::normalized::Bytecode";
                                                                Ty.path "alloc::alloc::Global"
                                                              ]
                                                          ],
                                                          "partial_cmp",
                                                          []
                                                        |),
                                                        [
                                                          M.SubPointer.get_struct_record_field (|
                                                            M.read (| self |),
                                                            "move_binary_format::normalized::Function",
                                                            "code"
                                                          |);
                                                          M.SubPointer.get_struct_record_field (|
                                                            M.read (| other |),
                                                            "move_binary_format::normalized::Function",
                                                            "code"
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let cmp := M.copy (| γ |) in
                                                    cmp))
                                              ]
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let cmp := M.copy (| γ |) in
                                            cmp))
                                      ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let cmp := M.copy (| γ |) in
                                    cmp))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let cmp := M.copy (| γ |) in
                            cmp))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let cmp := M.copy (| γ |) in
                    cmp))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::PartialOrd"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("partial_cmp", InstanceField.Method partial_cmp) ].
  End Impl_core_cmp_PartialOrd_for_move_binary_format_normalized_Function.
  
  Module Impl_core_cmp_Eq_for_move_binary_format_normalized_Function.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Function".
    
    (* Eq *)
    Definition assert_receiver_is_total_eq
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.read (|
            M.match_operator (|
              Value.DeclaredButUndefined,
              [
                fun γ =>
                  ltac:(M.monadic
                    (M.match_operator (|
                      Value.DeclaredButUndefined,
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              Value.DeclaredButUndefined,
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (M.match_operator (|
                                      Value.DeclaredButUndefined,
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.match_operator (|
                                              Value.DeclaredButUndefined,
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (M.match_operator (|
                                                      Value.DeclaredButUndefined,
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (M.alloc (| Value.Tuple [] |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::Eq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *)
        [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ].
  End Impl_core_cmp_Eq_for_move_binary_format_normalized_Function.
  
  Module Impl_core_marker_StructuralPartialEq_for_move_binary_format_normalized_Function.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Function".
    
    Axiom Implements :
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_move_binary_format_normalized_Function.
  
  Module Impl_core_cmp_PartialEq_for_move_binary_format_normalized_Function.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Function".
    
    (* PartialEq *)
    Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.and (|
            LogicalOp.and (|
              LogicalOp.and (|
                LogicalOp.and (|
                  LogicalOp.and (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "core::cmp::PartialEq",
                        Ty.path "move_binary_format::file_format::Visibility",
                        [ Ty.path "move_binary_format::file_format::Visibility" ],
                        "eq",
                        []
                      |),
                      [
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "move_binary_format::normalized::Function",
                          "visibility"
                        |);
                        M.SubPointer.get_struct_record_field (|
                          M.read (| other |),
                          "move_binary_format::normalized::Function",
                          "visibility"
                        |)
                      ]
                    |),
                    ltac:(M.monadic
                      (BinOp.eq (|
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| self |),
                            "move_binary_format::normalized::Function",
                            "is_entry"
                          |)
                        |),
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| other |),
                            "move_binary_format::normalized::Function",
                            "is_entry"
                          |)
                        |)
                      |)))
                  |),
                  ltac:(M.monadic
                    (M.call_closure (|
                      M.get_trait_method (|
                        "core::cmp::PartialEq",
                        Ty.apply
                          (Ty.path "alloc::vec::Vec")
                          []
                          [
                            Ty.path "move_binary_format::file_format::AbilitySet";
                            Ty.path "alloc::alloc::Global"
                          ],
                        [
                          Ty.apply
                            (Ty.path "alloc::vec::Vec")
                            []
                            [
                              Ty.path "move_binary_format::file_format::AbilitySet";
                              Ty.path "alloc::alloc::Global"
                            ]
                        ],
                        "eq",
                        []
                      |),
                      [
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "move_binary_format::normalized::Function",
                          "type_parameters"
                        |);
                        M.SubPointer.get_struct_record_field (|
                          M.read (| other |),
                          "move_binary_format::normalized::Function",
                          "type_parameters"
                        |)
                      ]
                    |)))
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_trait_method (|
                      "core::cmp::PartialEq",
                      Ty.apply
                        (Ty.path "alloc::vec::Vec")
                        []
                        [
                          Ty.path "move_binary_format::normalized::Type";
                          Ty.path "alloc::alloc::Global"
                        ],
                      [
                        Ty.apply
                          (Ty.path "alloc::vec::Vec")
                          []
                          [
                            Ty.path "move_binary_format::normalized::Type";
                            Ty.path "alloc::alloc::Global"
                          ]
                      ],
                      "eq",
                      []
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "move_binary_format::normalized::Function",
                        "parameters"
                      |);
                      M.SubPointer.get_struct_record_field (|
                        M.read (| other |),
                        "move_binary_format::normalized::Function",
                        "parameters"
                      |)
                    ]
                  |)))
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (|
                    "core::cmp::PartialEq",
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::normalized::Type";
                        Ty.path "alloc::alloc::Global"
                      ],
                    [
                      Ty.apply
                        (Ty.path "alloc::vec::Vec")
                        []
                        [
                          Ty.path "move_binary_format::normalized::Type";
                          Ty.path "alloc::alloc::Global"
                        ]
                    ],
                    "eq",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Function",
                      "return_"
                    |);
                    M.SubPointer.get_struct_record_field (|
                      M.read (| other |),
                      "move_binary_format::normalized::Function",
                      "return_"
                    |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (|
                  "core::cmp::PartialEq",
                  Ty.apply
                    (Ty.path "alloc::vec::Vec")
                    []
                    [
                      Ty.path "move_binary_format::normalized::Bytecode";
                      Ty.path "alloc::alloc::Global"
                    ],
                  [
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::normalized::Bytecode";
                        Ty.path "alloc::alloc::Global"
                      ]
                  ],
                  "eq",
                  []
                |),
                [
                  M.SubPointer.get_struct_record_field (|
                    M.read (| self |),
                    "move_binary_format::normalized::Function",
                    "code"
                  |);
                  M.SubPointer.get_struct_record_field (|
                    M.read (| other |),
                    "move_binary_format::normalized::Function",
                    "code"
                  |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::PartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("eq", InstanceField.Method eq) ].
  End Impl_core_cmp_PartialEq_for_move_binary_format_normalized_Function.
  
  
  
  (* StructRecord
    {
      name := "FieldRef";
      const_params := [];
      ty_params := [];
      fields :=
        [
          ("struct_name", Ty.path "move_core_types::identifier::Identifier");
          ("field_index", Ty.path "u16")
        ];
    } *)
  
  Module Impl_core_clone_Clone_for_move_binary_format_normalized_FieldRef.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::FieldRef".
    
    (* Clone *)
    Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          Value.StructRecord
            "move_binary_format::normalized::FieldRef"
            [
              ("struct_name",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.path "move_core_types::identifier::Identifier",
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::FieldRef",
                      "struct_name"
                    |)
                  ]
                |));
              ("field_index",
                M.call_closure (|
                  M.get_trait_method (| "core::clone::Clone", Ty.path "u16", [], "clone", [] |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::FieldRef",
                      "field_index"
                    |)
                  ]
                |))
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::clone::Clone"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("clone", InstanceField.Method clone) ].
  End Impl_core_clone_Clone_for_move_binary_format_normalized_FieldRef.
  
  Module Impl_core_fmt_Debug_for_move_binary_format_normalized_FieldRef.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::FieldRef".
    
    (* Debug *)
    Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; f ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let f := M.alloc (| f |) in
          M.call_closure (|
            M.get_associated_function (|
              Ty.path "core::fmt::Formatter",
              "debug_struct_field2_finish",
              []
            |),
            [
              M.read (| f |);
              M.read (| Value.String "FieldRef" |);
              M.read (| Value.String "struct_name" |);
              M.SubPointer.get_struct_record_field (|
                M.read (| self |),
                "move_binary_format::normalized::FieldRef",
                "struct_name"
              |);
              M.read (| Value.String "field_index" |);
              M.alloc (|
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "move_binary_format::normalized::FieldRef",
                  "field_index"
                |)
              |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::fmt::Debug"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
  End Impl_core_fmt_Debug_for_move_binary_format_normalized_FieldRef.
  
  Module Impl_core_cmp_Ord_for_move_binary_format_normalized_FieldRef.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::FieldRef".
    
    (* Ord *)
    Definition cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (|
                    "core::cmp::Ord",
                    Ty.path "move_core_types::identifier::Identifier",
                    [],
                    "cmp",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::FieldRef",
                      "struct_name"
                    |);
                    M.SubPointer.get_struct_record_field (|
                      M.read (| other |),
                      "move_binary_format::normalized::FieldRef",
                      "struct_name"
                    |)
                  ]
                |)
              |),
              [
                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", Ty.path "u16", [], "cmp", [] |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| self |),
                            "move_binary_format::normalized::FieldRef",
                            "field_index"
                          |);
                          M.SubPointer.get_struct_record_field (|
                            M.read (| other |),
                            "move_binary_format::normalized::FieldRef",
                            "field_index"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let cmp := M.copy (| γ |) in
                    cmp))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::Ord"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("cmp", InstanceField.Method cmp) ].
  End Impl_core_cmp_Ord_for_move_binary_format_normalized_FieldRef.
  
  Module Impl_core_cmp_PartialOrd_for_move_binary_format_normalized_FieldRef.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::FieldRef".
    
    (* PartialOrd *)
    Definition partial_cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (|
                    "core::cmp::PartialOrd",
                    Ty.path "move_core_types::identifier::Identifier",
                    [ Ty.path "move_core_types::identifier::Identifier" ],
                    "partial_cmp",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::FieldRef",
                      "struct_name"
                    |);
                    M.SubPointer.get_struct_record_field (|
                      M.read (| other |),
                      "move_binary_format::normalized::FieldRef",
                      "struct_name"
                    |)
                  ]
                |)
              |),
              [
                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",
                          Ty.path "u16",
                          [ Ty.path "u16" ],
                          "partial_cmp",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| self |),
                            "move_binary_format::normalized::FieldRef",
                            "field_index"
                          |);
                          M.SubPointer.get_struct_record_field (|
                            M.read (| other |),
                            "move_binary_format::normalized::FieldRef",
                            "field_index"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let cmp := M.copy (| γ |) in
                    cmp))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::PartialOrd"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("partial_cmp", InstanceField.Method partial_cmp) ].
  End Impl_core_cmp_PartialOrd_for_move_binary_format_normalized_FieldRef.
  
  Module Impl_core_cmp_Eq_for_move_binary_format_normalized_FieldRef.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::FieldRef".
    
    (* Eq *)
    Definition assert_receiver_is_total_eq
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.read (|
            M.match_operator (|
              Value.DeclaredButUndefined,
              [
                fun γ =>
                  ltac:(M.monadic
                    (M.match_operator (|
                      Value.DeclaredButUndefined,
                      [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::Eq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *)
        [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ].
  End Impl_core_cmp_Eq_for_move_binary_format_normalized_FieldRef.
  
  Module Impl_core_marker_StructuralPartialEq_for_move_binary_format_normalized_FieldRef.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::FieldRef".
    
    Axiom Implements :
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_move_binary_format_normalized_FieldRef.
  
  Module Impl_core_cmp_PartialEq_for_move_binary_format_normalized_FieldRef.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::FieldRef".
    
    (* PartialEq *)
    Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.and (|
            M.call_closure (|
              M.get_trait_method (|
                "core::cmp::PartialEq",
                Ty.path "move_core_types::identifier::Identifier",
                [ Ty.path "move_core_types::identifier::Identifier" ],
                "eq",
                []
              |),
              [
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "move_binary_format::normalized::FieldRef",
                  "struct_name"
                |);
                M.SubPointer.get_struct_record_field (|
                  M.read (| other |),
                  "move_binary_format::normalized::FieldRef",
                  "struct_name"
                |)
              ]
            |),
            ltac:(M.monadic
              (BinOp.eq (|
                M.read (|
                  M.SubPointer.get_struct_record_field (|
                    M.read (| self |),
                    "move_binary_format::normalized::FieldRef",
                    "field_index"
                  |)
                |),
                M.read (|
                  M.SubPointer.get_struct_record_field (|
                    M.read (| other |),
                    "move_binary_format::normalized::FieldRef",
                    "field_index"
                  |)
                |)
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::PartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("eq", InstanceField.Method eq) ].
  End Impl_core_cmp_PartialEq_for_move_binary_format_normalized_FieldRef.
  
  
  
  (* StructRecord
    {
      name := "FunctionRef";
      const_params := [];
      ty_params := [];
      fields :=
        [
          ("module_id", Ty.path "move_core_types::language_storage::ModuleId");
          ("function_ident", Ty.path "move_core_types::identifier::Identifier")
        ];
    } *)
  
  Module Impl_core_clone_Clone_for_move_binary_format_normalized_FunctionRef.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::FunctionRef".
    
    (* Clone *)
    Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          Value.StructRecord
            "move_binary_format::normalized::FunctionRef"
            [
              ("module_id",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.path "move_core_types::language_storage::ModuleId",
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::FunctionRef",
                      "module_id"
                    |)
                  ]
                |));
              ("function_ident",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.path "move_core_types::identifier::Identifier",
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::FunctionRef",
                      "function_ident"
                    |)
                  ]
                |))
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::clone::Clone"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("clone", InstanceField.Method clone) ].
  End Impl_core_clone_Clone_for_move_binary_format_normalized_FunctionRef.
  
  Module Impl_core_fmt_Debug_for_move_binary_format_normalized_FunctionRef.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::FunctionRef".
    
    (* Debug *)
    Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; f ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let f := M.alloc (| f |) in
          M.call_closure (|
            M.get_associated_function (|
              Ty.path "core::fmt::Formatter",
              "debug_struct_field2_finish",
              []
            |),
            [
              M.read (| f |);
              M.read (| Value.String "FunctionRef" |);
              M.read (| Value.String "module_id" |);
              M.SubPointer.get_struct_record_field (|
                M.read (| self |),
                "move_binary_format::normalized::FunctionRef",
                "module_id"
              |);
              M.read (| Value.String "function_ident" |);
              M.alloc (|
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "move_binary_format::normalized::FunctionRef",
                  "function_ident"
                |)
              |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::fmt::Debug"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
  End Impl_core_fmt_Debug_for_move_binary_format_normalized_FunctionRef.
  
  Module Impl_core_cmp_Ord_for_move_binary_format_normalized_FunctionRef.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::FunctionRef".
    
    (* Ord *)
    Definition cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (|
                    "core::cmp::Ord",
                    Ty.path "move_core_types::language_storage::ModuleId",
                    [],
                    "cmp",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::FunctionRef",
                      "module_id"
                    |);
                    M.SubPointer.get_struct_record_field (|
                      M.read (| other |),
                      "move_binary_format::normalized::FunctionRef",
                      "module_id"
                    |)
                  ]
                |)
              |),
              [
                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",
                          Ty.path "move_core_types::identifier::Identifier",
                          [],
                          "cmp",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| self |),
                            "move_binary_format::normalized::FunctionRef",
                            "function_ident"
                          |);
                          M.SubPointer.get_struct_record_field (|
                            M.read (| other |),
                            "move_binary_format::normalized::FunctionRef",
                            "function_ident"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let cmp := M.copy (| γ |) in
                    cmp))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::Ord"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("cmp", InstanceField.Method cmp) ].
  End Impl_core_cmp_Ord_for_move_binary_format_normalized_FunctionRef.
  
  Module Impl_core_cmp_PartialOrd_for_move_binary_format_normalized_FunctionRef.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::FunctionRef".
    
    (* PartialOrd *)
    Definition partial_cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (|
                    "core::cmp::PartialOrd",
                    Ty.path "move_core_types::language_storage::ModuleId",
                    [ Ty.path "move_core_types::language_storage::ModuleId" ],
                    "partial_cmp",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::FunctionRef",
                      "module_id"
                    |);
                    M.SubPointer.get_struct_record_field (|
                      M.read (| other |),
                      "move_binary_format::normalized::FunctionRef",
                      "module_id"
                    |)
                  ]
                |)
              |),
              [
                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",
                          Ty.path "move_core_types::identifier::Identifier",
                          [ Ty.path "move_core_types::identifier::Identifier" ],
                          "partial_cmp",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| self |),
                            "move_binary_format::normalized::FunctionRef",
                            "function_ident"
                          |);
                          M.SubPointer.get_struct_record_field (|
                            M.read (| other |),
                            "move_binary_format::normalized::FunctionRef",
                            "function_ident"
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let cmp := M.copy (| γ |) in
                    cmp))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::PartialOrd"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("partial_cmp", InstanceField.Method partial_cmp) ].
  End Impl_core_cmp_PartialOrd_for_move_binary_format_normalized_FunctionRef.
  
  Module Impl_core_cmp_Eq_for_move_binary_format_normalized_FunctionRef.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::FunctionRef".
    
    (* Eq *)
    Definition assert_receiver_is_total_eq
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.read (|
            M.match_operator (|
              Value.DeclaredButUndefined,
              [
                fun γ =>
                  ltac:(M.monadic
                    (M.match_operator (|
                      Value.DeclaredButUndefined,
                      [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::Eq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *)
        [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ].
  End Impl_core_cmp_Eq_for_move_binary_format_normalized_FunctionRef.
  
  Module Impl_core_marker_StructuralPartialEq_for_move_binary_format_normalized_FunctionRef.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::FunctionRef".
    
    Axiom Implements :
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_move_binary_format_normalized_FunctionRef.
  
  Module Impl_core_cmp_PartialEq_for_move_binary_format_normalized_FunctionRef.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::FunctionRef".
    
    (* PartialEq *)
    Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.and (|
            M.call_closure (|
              M.get_trait_method (|
                "core::cmp::PartialEq",
                Ty.path "move_core_types::language_storage::ModuleId",
                [ Ty.path "move_core_types::language_storage::ModuleId" ],
                "eq",
                []
              |),
              [
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "move_binary_format::normalized::FunctionRef",
                  "module_id"
                |);
                M.SubPointer.get_struct_record_field (|
                  M.read (| other |),
                  "move_binary_format::normalized::FunctionRef",
                  "module_id"
                |)
              ]
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (|
                  "core::cmp::PartialEq",
                  Ty.path "move_core_types::identifier::Identifier",
                  [ Ty.path "move_core_types::identifier::Identifier" ],
                  "eq",
                  []
                |),
                [
                  M.SubPointer.get_struct_record_field (|
                    M.read (| self |),
                    "move_binary_format::normalized::FunctionRef",
                    "function_ident"
                  |);
                  M.SubPointer.get_struct_record_field (|
                    M.read (| other |),
                    "move_binary_format::normalized::FunctionRef",
                    "function_ident"
                  |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::PartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("eq", InstanceField.Method eq) ].
  End Impl_core_cmp_PartialEq_for_move_binary_format_normalized_FunctionRef.
  
  
  
  (*
  Enum Bytecode
  {
    const_params := [];
    ty_params := [];
    variants :=
      [
        {
          name := "Pop";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Ret";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "BrTrue";
          item := StructTuple [ Ty.path "u16" ];
          discriminant := None;
        };
        {
          name := "BrFalse";
          item := StructTuple [ Ty.path "u16" ];
          discriminant := None;
        };
        {
          name := "Branch";
          item := StructTuple [ Ty.path "u16" ];
          discriminant := None;
        };
        {
          name := "LdU8";
          item := StructTuple [ Ty.path "u8" ];
          discriminant := None;
        };
        {
          name := "LdU64";
          item := StructTuple [ Ty.path "u64" ];
          discriminant := None;
        };
        {
          name := "LdU128";
          item := StructTuple [ Ty.path "u128" ];
          discriminant := None;
        };
        {
          name := "CastU8";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "CastU64";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "CastU128";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "LdConst";
          item := StructTuple [ Ty.path "move_binary_format::normalized::Constant" ];
          discriminant := None;
        };
        {
          name := "LdTrue";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "LdFalse";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "CopyLoc";
          item := StructTuple [ Ty.path "u8" ];
          discriminant := None;
        };
        {
          name := "MoveLoc";
          item := StructTuple [ Ty.path "u8" ];
          discriminant := None;
        };
        {
          name := "StLoc";
          item := StructTuple [ Ty.path "u8" ];
          discriminant := None;
        };
        {
          name := "Call";
          item := StructTuple [ Ty.path "move_binary_format::normalized::FunctionRef" ];
          discriminant := None;
        };
        {
          name := "CallGeneric";
          item :=
            StructTuple
              [
                Ty.tuple
                  [
                    Ty.path "move_binary_format::normalized::FunctionRef";
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::normalized::Type";
                        Ty.path "alloc::alloc::Global"
                      ]
                  ]
              ];
          discriminant := None;
        };
        {
          name := "Pack";
          item := StructTuple [ Ty.path "move_core_types::identifier::Identifier" ];
          discriminant := None;
        };
        {
          name := "PackGeneric";
          item :=
            StructTuple
              [
                Ty.tuple
                  [
                    Ty.path "move_core_types::identifier::Identifier";
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::normalized::Type";
                        Ty.path "alloc::alloc::Global"
                      ]
                  ]
              ];
          discriminant := None;
        };
        {
          name := "Unpack";
          item := StructTuple [ Ty.path "move_core_types::identifier::Identifier" ];
          discriminant := None;
        };
        {
          name := "UnpackGeneric";
          item :=
            StructTuple
              [
                Ty.tuple
                  [
                    Ty.path "move_core_types::identifier::Identifier";
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::normalized::Type";
                        Ty.path "alloc::alloc::Global"
                      ]
                  ]
              ];
          discriminant := None;
        };
        {
          name := "ReadRef";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "WriteRef";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "FreezeRef";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "MutBorrowLoc";
          item := StructTuple [ Ty.path "u8" ];
          discriminant := None;
        };
        {
          name := "ImmBorrowLoc";
          item := StructTuple [ Ty.path "u8" ];
          discriminant := None;
        };
        {
          name := "MutBorrowField";
          item := StructTuple [ Ty.path "move_binary_format::normalized::FieldRef" ];
          discriminant := None;
        };
        {
          name := "MutBorrowFieldGeneric";
          item :=
            StructTuple
              [
                Ty.tuple
                  [
                    Ty.path "move_binary_format::normalized::FieldRef";
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::normalized::Type";
                        Ty.path "alloc::alloc::Global"
                      ]
                  ]
              ];
          discriminant := None;
        };
        {
          name := "ImmBorrowField";
          item := StructTuple [ Ty.path "move_binary_format::normalized::FieldRef" ];
          discriminant := None;
        };
        {
          name := "ImmBorrowFieldGeneric";
          item :=
            StructTuple
              [
                Ty.tuple
                  [
                    Ty.path "move_binary_format::normalized::FieldRef";
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::normalized::Type";
                        Ty.path "alloc::alloc::Global"
                      ]
                  ]
              ];
          discriminant := None;
        };
        {
          name := "Add";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Sub";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Mul";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Mod";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Div";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "BitOr";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "BitAnd";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Xor";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Or";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "And";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Not";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Eq";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Neq";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Lt";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Gt";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Le";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Ge";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Abort";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Nop";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Shl";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Shr";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "VecPack";
          item := StructTuple [ Ty.path "move_binary_format::normalized::Type"; Ty.path "u64" ];
          discriminant := None;
        };
        {
          name := "VecLen";
          item := StructTuple [ Ty.path "move_binary_format::normalized::Type" ];
          discriminant := None;
        };
        {
          name := "VecImmBorrow";
          item := StructTuple [ Ty.path "move_binary_format::normalized::Type" ];
          discriminant := None;
        };
        {
          name := "VecMutBorrow";
          item := StructTuple [ Ty.path "move_binary_format::normalized::Type" ];
          discriminant := None;
        };
        {
          name := "VecPushBack";
          item := StructTuple [ Ty.path "move_binary_format::normalized::Type" ];
          discriminant := None;
        };
        {
          name := "VecPopBack";
          item := StructTuple [ Ty.path "move_binary_format::normalized::Type" ];
          discriminant := None;
        };
        {
          name := "VecUnpack";
          item := StructTuple [ Ty.path "move_binary_format::normalized::Type"; Ty.path "u64" ];
          discriminant := None;
        };
        {
          name := "VecSwap";
          item := StructTuple [ Ty.path "move_binary_format::normalized::Type" ];
          discriminant := None;
        };
        {
          name := "LdU16";
          item := StructTuple [ Ty.path "u16" ];
          discriminant := None;
        };
        {
          name := "LdU32";
          item := StructTuple [ Ty.path "u32" ];
          discriminant := None;
        };
        {
          name := "LdU256";
          item := StructTuple [ Ty.path "move_core_types::u256::U256" ];
          discriminant := None;
        };
        {
          name := "CastU16";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "CastU32";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "CastU256";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "MutBorrowGlobalDeprecated";
          item := StructTuple [ Ty.path "move_core_types::identifier::Identifier" ];
          discriminant := None;
        };
        {
          name := "MutBorrowGlobalGenericDeprecated";
          item :=
            StructTuple
              [
                Ty.tuple
                  [
                    Ty.path "move_core_types::identifier::Identifier";
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::normalized::Type";
                        Ty.path "alloc::alloc::Global"
                      ]
                  ]
              ];
          discriminant := None;
        };
        {
          name := "ImmBorrowGlobalDeprecated";
          item := StructTuple [ Ty.path "move_core_types::identifier::Identifier" ];
          discriminant := None;
        };
        {
          name := "ImmBorrowGlobalGenericDeprecated";
          item :=
            StructTuple
              [
                Ty.tuple
                  [
                    Ty.path "move_core_types::identifier::Identifier";
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::normalized::Type";
                        Ty.path "alloc::alloc::Global"
                      ]
                  ]
              ];
          discriminant := None;
        };
        {
          name := "ExistsDeprecated";
          item := StructTuple [ Ty.path "move_core_types::identifier::Identifier" ];
          discriminant := None;
        };
        {
          name := "ExistsGenericDeprecated";
          item :=
            StructTuple
              [
                Ty.tuple
                  [
                    Ty.path "move_core_types::identifier::Identifier";
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::normalized::Type";
                        Ty.path "alloc::alloc::Global"
                      ]
                  ]
              ];
          discriminant := None;
        };
        {
          name := "MoveFromDeprecated";
          item := StructTuple [ Ty.path "move_core_types::identifier::Identifier" ];
          discriminant := None;
        };
        {
          name := "MoveFromGenericDeprecated";
          item :=
            StructTuple
              [
                Ty.tuple
                  [
                    Ty.path "move_core_types::identifier::Identifier";
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::normalized::Type";
                        Ty.path "alloc::alloc::Global"
                      ]
                  ]
              ];
          discriminant := None;
        };
        {
          name := "MoveToDeprecated";
          item := StructTuple [ Ty.path "move_core_types::identifier::Identifier" ];
          discriminant := None;
        };
        {
          name := "MoveToGenericDeprecated";
          item :=
            StructTuple
              [
                Ty.tuple
                  [
                    Ty.path "move_core_types::identifier::Identifier";
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::normalized::Type";
                        Ty.path "alloc::alloc::Global"
                      ]
                  ]
              ];
          discriminant := None;
        }
      ];
  }
  *)
  
  Module Impl_core_clone_Clone_for_move_binary_format_normalized_Bytecode.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Bytecode".
    
    (* Clone *)
    Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.read (|
            M.match_operator (|
              self,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Pop" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Pop" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Ret" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Ret" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::BrTrue",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::BrTrue"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "u16",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::BrFalse",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::BrFalse"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "u16",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::Branch",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::Branch"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "u16",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::LdU8",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::LdU8"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "u8",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::LdU64",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::LdU64"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "u64",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::LdU128",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::LdU128"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "u128",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::CastU8"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::CastU8" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::CastU64"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::CastU64" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::CastU128"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::CastU128" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::LdConst",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::LdConst"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_binary_format::normalized::Constant",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::LdTrue"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::LdTrue" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::LdFalse"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::LdFalse" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::CopyLoc",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::CopyLoc"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "u8",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::MoveLoc",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::MoveLoc"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "u8",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::StLoc",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::StLoc"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "u8",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::Call",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::Call"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_binary_format::normalized::FunctionRef",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::CallGeneric",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::CallGeneric"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.tuple
                                [
                                  Ty.path "move_binary_format::normalized::FunctionRef";
                                  Ty.apply
                                    (Ty.path "alloc::vec::Vec")
                                    []
                                    [
                                      Ty.path "move_binary_format::normalized::Type";
                                      Ty.path "alloc::alloc::Global"
                                    ]
                                ],
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::Pack",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::Pack"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_core_types::identifier::Identifier",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::PackGeneric",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::PackGeneric"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.tuple
                                [
                                  Ty.path "move_core_types::identifier::Identifier";
                                  Ty.apply
                                    (Ty.path "alloc::vec::Vec")
                                    []
                                    [
                                      Ty.path "move_binary_format::normalized::Type";
                                      Ty.path "alloc::alloc::Global"
                                    ]
                                ],
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::Unpack",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::Unpack"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_core_types::identifier::Identifier",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::UnpackGeneric",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::UnpackGeneric"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.tuple
                                [
                                  Ty.path "move_core_types::identifier::Identifier";
                                  Ty.apply
                                    (Ty.path "alloc::vec::Vec")
                                    []
                                    [
                                      Ty.path "move_binary_format::normalized::Type";
                                      Ty.path "alloc::alloc::Global"
                                    ]
                                ],
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::ReadRef"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::ReadRef" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::WriteRef"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::WriteRef" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::FreezeRef"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::FreezeRef" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::MutBorrowLoc",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::MutBorrowLoc"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "u8",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::ImmBorrowLoc",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::ImmBorrowLoc"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "u8",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::MutBorrowField",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::MutBorrowField"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_binary_format::normalized::FieldRef",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::MutBorrowFieldGeneric",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::MutBorrowFieldGeneric"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.tuple
                                [
                                  Ty.path "move_binary_format::normalized::FieldRef";
                                  Ty.apply
                                    (Ty.path "alloc::vec::Vec")
                                    []
                                    [
                                      Ty.path "move_binary_format::normalized::Type";
                                      Ty.path "alloc::alloc::Global"
                                    ]
                                ],
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::ImmBorrowField",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::ImmBorrowField"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_binary_format::normalized::FieldRef",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::ImmBorrowFieldGeneric",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::ImmBorrowFieldGeneric"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.tuple
                                [
                                  Ty.path "move_binary_format::normalized::FieldRef";
                                  Ty.apply
                                    (Ty.path "alloc::vec::Vec")
                                    []
                                    [
                                      Ty.path "move_binary_format::normalized::Type";
                                      Ty.path "alloc::alloc::Global"
                                    ]
                                ],
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Add" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Add" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Sub" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Sub" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Mul" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Mul" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Mod" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Mod" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Div" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Div" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::BitOr"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::BitOr" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::BitAnd"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::BitAnd" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Xor" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Xor" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Or" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Or" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::And" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::And" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Not" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Not" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Eq" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Eq" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Neq" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Neq" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Lt" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Lt" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Gt" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Gt" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Le" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Le" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Ge" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Ge" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::Abort"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Abort" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Nop" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Nop" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Shl" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Shl" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Shr" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Shr" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::VecPack",
                        0
                      |) in
                    let γ1_1 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::VecPack",
                        1
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    let __self_1 := M.alloc (| γ1_1 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::VecPack"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_binary_format::normalized::Type",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |);
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "u64",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_1 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::VecLen",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::VecLen"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_binary_format::normalized::Type",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::VecImmBorrow",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::VecImmBorrow"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_binary_format::normalized::Type",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::VecMutBorrow",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::VecMutBorrow"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_binary_format::normalized::Type",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::VecPushBack",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::VecPushBack"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_binary_format::normalized::Type",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::VecPopBack",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::VecPopBack"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_binary_format::normalized::Type",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::VecUnpack",
                        0
                      |) in
                    let γ1_1 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::VecUnpack",
                        1
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    let __self_1 := M.alloc (| γ1_1 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::VecUnpack"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_binary_format::normalized::Type",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |);
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "u64",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_1 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::VecSwap",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::VecSwap"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_binary_format::normalized::Type",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::LdU16",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::LdU16"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "u16",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::LdU32",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::LdU32"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "u32",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::LdU256",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::LdU256"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_core_types::u256::U256",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::CastU16"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::CastU16" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::CastU32"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::CastU32" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::CastU256"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::CastU256" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::MutBorrowGlobalDeprecated",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::MutBorrowGlobalDeprecated"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_core_types::identifier::Identifier",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::MutBorrowGlobalGenericDeprecated",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::MutBorrowGlobalGenericDeprecated"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.tuple
                                [
                                  Ty.path "move_core_types::identifier::Identifier";
                                  Ty.apply
                                    (Ty.path "alloc::vec::Vec")
                                    []
                                    [
                                      Ty.path "move_binary_format::normalized::Type";
                                      Ty.path "alloc::alloc::Global"
                                    ]
                                ],
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::ImmBorrowGlobalDeprecated",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::ImmBorrowGlobalDeprecated"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_core_types::identifier::Identifier",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::ImmBorrowGlobalGenericDeprecated",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::ImmBorrowGlobalGenericDeprecated"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.tuple
                                [
                                  Ty.path "move_core_types::identifier::Identifier";
                                  Ty.apply
                                    (Ty.path "alloc::vec::Vec")
                                    []
                                    [
                                      Ty.path "move_binary_format::normalized::Type";
                                      Ty.path "alloc::alloc::Global"
                                    ]
                                ],
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::ExistsDeprecated",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::ExistsDeprecated"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_core_types::identifier::Identifier",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::ExistsGenericDeprecated",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::ExistsGenericDeprecated"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.tuple
                                [
                                  Ty.path "move_core_types::identifier::Identifier";
                                  Ty.apply
                                    (Ty.path "alloc::vec::Vec")
                                    []
                                    [
                                      Ty.path "move_binary_format::normalized::Type";
                                      Ty.path "alloc::alloc::Global"
                                    ]
                                ],
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::MoveFromDeprecated",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::MoveFromDeprecated"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_core_types::identifier::Identifier",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::MoveFromGenericDeprecated",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::MoveFromGenericDeprecated"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.tuple
                                [
                                  Ty.path "move_core_types::identifier::Identifier";
                                  Ty.apply
                                    (Ty.path "alloc::vec::Vec")
                                    []
                                    [
                                      Ty.path "move_binary_format::normalized::Type";
                                      Ty.path "alloc::alloc::Global"
                                    ]
                                ],
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::MoveToDeprecated",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::MoveToDeprecated"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_core_types::identifier::Identifier",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::MoveToGenericDeprecated",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::MoveToGenericDeprecated"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.tuple
                                [
                                  Ty.path "move_core_types::identifier::Identifier";
                                  Ty.apply
                                    (Ty.path "alloc::vec::Vec")
                                    []
                                    [
                                      Ty.path "move_binary_format::normalized::Type";
                                      Ty.path "alloc::alloc::Global"
                                    ]
                                ],
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::clone::Clone"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("clone", InstanceField.Method clone) ].
  End Impl_core_clone_Clone_for_move_binary_format_normalized_Bytecode.
  
  Module Impl_core_fmt_Debug_for_move_binary_format_normalized_Bytecode.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Bytecode".
    
    (* Debug *)
    Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; f ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let f := M.alloc (| f |) in
          M.read (|
            M.match_operator (|
              self,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Pop" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Pop" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Ret" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Ret" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::BrTrue",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "BrTrue" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::BrFalse",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "BrFalse" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::Branch",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Branch" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::LdU8",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "LdU8" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::LdU64",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "LdU64" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::LdU128",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "LdU128" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::CastU8"
                      |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "CastU8" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::CastU64"
                      |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "CastU64" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::CastU128"
                      |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "CastU128" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::LdConst",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "LdConst" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::LdTrue"
                      |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "LdTrue" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::LdFalse"
                      |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "LdFalse" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::CopyLoc",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "CopyLoc" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::MoveLoc",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "MoveLoc" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::StLoc",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "StLoc" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::Call",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Call" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::CallGeneric",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "CallGeneric" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::Pack",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Pack" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::PackGeneric",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "PackGeneric" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::Unpack",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Unpack" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::UnpackGeneric",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "UnpackGeneric" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::ReadRef"
                      |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "ReadRef" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::WriteRef"
                      |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "WriteRef" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::FreezeRef"
                      |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "FreezeRef" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::MutBorrowLoc",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "MutBorrowLoc" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::ImmBorrowLoc",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "ImmBorrowLoc" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::MutBorrowField",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "MutBorrowField" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::MutBorrowFieldGeneric",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [
                          M.read (| f |);
                          M.read (| Value.String "MutBorrowFieldGeneric" |);
                          __self_0
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::ImmBorrowField",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "ImmBorrowField" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::ImmBorrowFieldGeneric",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [
                          M.read (| f |);
                          M.read (| Value.String "ImmBorrowFieldGeneric" |);
                          __self_0
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Add" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Add" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Sub" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Sub" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Mul" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Mul" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Mod" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Mod" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Div" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Div" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::BitOr"
                      |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "BitOr" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::BitAnd"
                      |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "BitAnd" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Xor" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Xor" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Or" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Or" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::And" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "And" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Not" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Not" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Eq" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Eq" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Neq" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Neq" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Lt" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Lt" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Gt" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Gt" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Le" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Le" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Ge" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Ge" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::Abort"
                      |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Abort" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Nop" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Nop" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Shl" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Shl" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Bytecode::Shr" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "Shr" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::VecPack",
                        0
                      |) in
                    let γ1_1 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::VecPack",
                        1
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    let __self_1 := M.alloc (| γ1_1 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field2_finish",
                          []
                        |),
                        [
                          M.read (| f |);
                          M.read (| Value.String "VecPack" |);
                          M.read (| __self_0 |);
                          __self_1
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::VecLen",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "VecLen" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::VecImmBorrow",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "VecImmBorrow" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::VecMutBorrow",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "VecMutBorrow" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::VecPushBack",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "VecPushBack" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::VecPopBack",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "VecPopBack" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::VecUnpack",
                        0
                      |) in
                    let γ1_1 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::VecUnpack",
                        1
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    let __self_1 := M.alloc (| γ1_1 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field2_finish",
                          []
                        |),
                        [
                          M.read (| f |);
                          M.read (| Value.String "VecUnpack" |);
                          M.read (| __self_0 |);
                          __self_1
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::VecSwap",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "VecSwap" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::LdU16",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "LdU16" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::LdU32",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "LdU32" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::LdU256",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "LdU256" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::CastU16"
                      |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "CastU16" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::CastU32"
                      |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "CastU32" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::normalized::Bytecode::CastU256"
                      |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "write_str",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "CastU256" |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::MutBorrowGlobalDeprecated",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [
                          M.read (| f |);
                          M.read (| Value.String "MutBorrowGlobalDeprecated" |);
                          __self_0
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::MutBorrowGlobalGenericDeprecated",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [
                          M.read (| f |);
                          M.read (| Value.String "MutBorrowGlobalGenericDeprecated" |);
                          __self_0
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::ImmBorrowGlobalDeprecated",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [
                          M.read (| f |);
                          M.read (| Value.String "ImmBorrowGlobalDeprecated" |);
                          __self_0
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::ImmBorrowGlobalGenericDeprecated",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [
                          M.read (| f |);
                          M.read (| Value.String "ImmBorrowGlobalGenericDeprecated" |);
                          __self_0
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::ExistsDeprecated",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "ExistsDeprecated" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::ExistsGenericDeprecated",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [
                          M.read (| f |);
                          M.read (| Value.String "ExistsGenericDeprecated" |);
                          __self_0
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::MoveFromDeprecated",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "MoveFromDeprecated" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::MoveFromGenericDeprecated",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [
                          M.read (| f |);
                          M.read (| Value.String "MoveFromGenericDeprecated" |);
                          __self_0
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::MoveToDeprecated",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [ M.read (| f |); M.read (| Value.String "MoveToDeprecated" |); __self_0 ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Bytecode::MoveToGenericDeprecated",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::fmt::Formatter",
                          "debug_tuple_field1_finish",
                          []
                        |),
                        [
                          M.read (| f |);
                          M.read (| Value.String "MoveToGenericDeprecated" |);
                          __self_0
                        ]
                      |)
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::fmt::Debug"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
  End Impl_core_fmt_Debug_for_move_binary_format_normalized_Bytecode.
  
  Module Impl_core_cmp_Ord_for_move_binary_format_normalized_Bytecode.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Bytecode".
    
    (* Ord *)
    Definition cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ __self_discr :=
              M.alloc (|
                M.call_closure (|
                  M.get_function (|
                    "core::intrinsics::discriminant_value",
                    [ Ty.path "move_binary_format::normalized::Bytecode" ]
                  |),
                  [ M.read (| self |) ]
                |)
              |) in
            let~ __arg1_discr :=
              M.alloc (|
                M.call_closure (|
                  M.get_function (|
                    "core::intrinsics::discriminant_value",
                    [ Ty.path "move_binary_format::normalized::Bytecode" ]
                  |),
                  [ M.read (| other |) ]
                |)
              |) in
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::Ord", Ty.path "isize", [], "cmp", [] |),
                  [ __self_discr; __arg1_discr ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [ M.read (| self |); M.read (| other |) ] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::BrTrue",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::BrTrue",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "u16",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::BrFalse",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::BrFalse",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "u16",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::Branch",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::Branch",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "u16",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::LdU8",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::LdU8",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "u8",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::LdU64",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::LdU64",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "u64",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::LdU128",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::LdU128",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "u128",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::LdConst",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::LdConst",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "move_binary_format::normalized::Constant",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::CopyLoc",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::CopyLoc",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "u8",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MoveLoc",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MoveLoc",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "u8",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::StLoc",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::StLoc",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "u8",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::Call",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::Call",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "move_binary_format::normalized::FunctionRef",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::CallGeneric",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::CallGeneric",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.tuple
                                    [
                                      Ty.path "move_binary_format::normalized::FunctionRef";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::Pack",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::Pack",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "move_core_types::identifier::Identifier",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::PackGeneric",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::PackGeneric",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.tuple
                                    [
                                      Ty.path "move_core_types::identifier::Identifier";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::Unpack",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::Unpack",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "move_core_types::identifier::Identifier",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::UnpackGeneric",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::UnpackGeneric",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.tuple
                                    [
                                      Ty.path "move_core_types::identifier::Identifier";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MutBorrowLoc",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MutBorrowLoc",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "u8",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::ImmBorrowLoc",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::ImmBorrowLoc",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "u8",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MutBorrowField",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MutBorrowField",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "move_binary_format::normalized::FieldRef",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MutBorrowFieldGeneric",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MutBorrowFieldGeneric",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.tuple
                                    [
                                      Ty.path "move_binary_format::normalized::FieldRef";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::ImmBorrowField",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::ImmBorrowField",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "move_binary_format::normalized::FieldRef",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::ImmBorrowFieldGeneric",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::ImmBorrowFieldGeneric",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.tuple
                                    [
                                      Ty.path "move_binary_format::normalized::FieldRef";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecPack",
                                0
                              |) in
                            let γ2_1 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecPack",
                                1
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let __self_1 := M.alloc (| γ2_1 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecPack",
                                0
                              |) in
                            let γ2_1 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecPack",
                                1
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            let __arg1_1 := M.alloc (| γ2_1 |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::Ord",
                                    Ty.path "move_binary_format::normalized::Type",
                                    [],
                                    "cmp",
                                    []
                                  |),
                                  [ M.read (| __self_0 |); M.read (| __arg1_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",
                                          Ty.path "u64",
                                          [],
                                          "cmp",
                                          []
                                        |),
                                        [ M.read (| __self_1 |); M.read (| __arg1_1 |) ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let cmp := M.copy (| γ |) in
                                    cmp))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecLen",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecLen",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "move_binary_format::normalized::Type",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecImmBorrow",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecImmBorrow",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "move_binary_format::normalized::Type",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecMutBorrow",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecMutBorrow",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "move_binary_format::normalized::Type",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecPushBack",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecPushBack",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "move_binary_format::normalized::Type",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecPopBack",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecPopBack",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "move_binary_format::normalized::Type",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecUnpack",
                                0
                              |) in
                            let γ2_1 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecUnpack",
                                1
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let __self_1 := M.alloc (| γ2_1 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecUnpack",
                                0
                              |) in
                            let γ2_1 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecUnpack",
                                1
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            let __arg1_1 := M.alloc (| γ2_1 |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::Ord",
                                    Ty.path "move_binary_format::normalized::Type",
                                    [],
                                    "cmp",
                                    []
                                  |),
                                  [ M.read (| __self_0 |); M.read (| __arg1_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",
                                          Ty.path "u64",
                                          [],
                                          "cmp",
                                          []
                                        |),
                                        [ M.read (| __self_1 |); M.read (| __arg1_1 |) ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let cmp := M.copy (| γ |) in
                                    cmp))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecSwap",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecSwap",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "move_binary_format::normalized::Type",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::LdU16",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::LdU16",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "u16",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::LdU32",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::LdU32",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "u32",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::LdU256",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::LdU256",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "move_core_types::u256::U256",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MutBorrowGlobalDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MutBorrowGlobalDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "move_core_types::identifier::Identifier",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MutBorrowGlobalGenericDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MutBorrowGlobalGenericDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.tuple
                                    [
                                      Ty.path "move_core_types::identifier::Identifier";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::ImmBorrowGlobalDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::ImmBorrowGlobalDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "move_core_types::identifier::Identifier",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::ImmBorrowGlobalGenericDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::ImmBorrowGlobalGenericDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.tuple
                                    [
                                      Ty.path "move_core_types::identifier::Identifier";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::ExistsDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::ExistsDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "move_core_types::identifier::Identifier",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::ExistsGenericDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::ExistsGenericDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.tuple
                                    [
                                      Ty.path "move_core_types::identifier::Identifier";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MoveFromDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MoveFromDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "move_core_types::identifier::Identifier",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MoveFromGenericDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MoveFromGenericDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.tuple
                                    [
                                      Ty.path "move_core_types::identifier::Identifier";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MoveToDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MoveToDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.path "move_core_types::identifier::Identifier",
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MoveToGenericDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MoveToGenericDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::Ord",
                                  Ty.tuple
                                    [
                                      Ty.path "move_core_types::identifier::Identifier";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [],
                                  "cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (M.alloc (| Value.StructTuple "core::cmp::Ordering::Equal" [] |)))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let cmp := M.copy (| γ |) in
                    cmp))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::Ord"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("cmp", InstanceField.Method cmp) ].
  End Impl_core_cmp_Ord_for_move_binary_format_normalized_Bytecode.
  
  Module Impl_core_cmp_PartialOrd_for_move_binary_format_normalized_Bytecode.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Bytecode".
    
    (* PartialOrd *)
    Definition partial_cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ __self_discr :=
              M.alloc (|
                M.call_closure (|
                  M.get_function (|
                    "core::intrinsics::discriminant_value",
                    [ Ty.path "move_binary_format::normalized::Bytecode" ]
                  |),
                  [ M.read (| self |) ]
                |)
              |) in
            let~ __arg1_discr :=
              M.alloc (|
                M.call_closure (|
                  M.get_function (|
                    "core::intrinsics::discriminant_value",
                    [ Ty.path "move_binary_format::normalized::Bytecode" ]
                  |),
                  [ M.read (| other |) ]
                |)
              |) in
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (|
                    "core::cmp::PartialOrd",
                    Ty.path "isize",
                    [ Ty.path "isize" ],
                    "partial_cmp",
                    []
                  |),
                  [ __self_discr; __arg1_discr ]
                |)
              |),
              [
                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 (| Value.Tuple [ M.read (| self |); M.read (| other |) ] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::BrTrue",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::BrTrue",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "u16",
                                  [ Ty.path "u16" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::BrFalse",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::BrFalse",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "u16",
                                  [ Ty.path "u16" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::Branch",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::Branch",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "u16",
                                  [ Ty.path "u16" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::LdU8",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::LdU8",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "u8",
                                  [ Ty.path "u8" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::LdU64",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::LdU64",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "u64",
                                  [ Ty.path "u64" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::LdU128",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::LdU128",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "u128",
                                  [ Ty.path "u128" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::LdConst",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::LdConst",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "move_binary_format::normalized::Constant",
                                  [ Ty.path "move_binary_format::normalized::Constant" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::CopyLoc",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::CopyLoc",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "u8",
                                  [ Ty.path "u8" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MoveLoc",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MoveLoc",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "u8",
                                  [ Ty.path "u8" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::StLoc",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::StLoc",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "u8",
                                  [ Ty.path "u8" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::Call",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::Call",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "move_binary_format::normalized::FunctionRef",
                                  [ Ty.path "move_binary_format::normalized::FunctionRef" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::CallGeneric",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::CallGeneric",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.tuple
                                    [
                                      Ty.path "move_binary_format::normalized::FunctionRef";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [
                                    Ty.tuple
                                      [
                                        Ty.path "move_binary_format::normalized::FunctionRef";
                                        Ty.apply
                                          (Ty.path "alloc::vec::Vec")
                                          []
                                          [
                                            Ty.path "move_binary_format::normalized::Type";
                                            Ty.path "alloc::alloc::Global"
                                          ]
                                      ]
                                  ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::Pack",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::Pack",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "move_core_types::identifier::Identifier",
                                  [ Ty.path "move_core_types::identifier::Identifier" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::PackGeneric",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::PackGeneric",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.tuple
                                    [
                                      Ty.path "move_core_types::identifier::Identifier";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [
                                    Ty.tuple
                                      [
                                        Ty.path "move_core_types::identifier::Identifier";
                                        Ty.apply
                                          (Ty.path "alloc::vec::Vec")
                                          []
                                          [
                                            Ty.path "move_binary_format::normalized::Type";
                                            Ty.path "alloc::alloc::Global"
                                          ]
                                      ]
                                  ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::Unpack",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::Unpack",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "move_core_types::identifier::Identifier",
                                  [ Ty.path "move_core_types::identifier::Identifier" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::UnpackGeneric",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::UnpackGeneric",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.tuple
                                    [
                                      Ty.path "move_core_types::identifier::Identifier";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [
                                    Ty.tuple
                                      [
                                        Ty.path "move_core_types::identifier::Identifier";
                                        Ty.apply
                                          (Ty.path "alloc::vec::Vec")
                                          []
                                          [
                                            Ty.path "move_binary_format::normalized::Type";
                                            Ty.path "alloc::alloc::Global"
                                          ]
                                      ]
                                  ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MutBorrowLoc",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MutBorrowLoc",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "u8",
                                  [ Ty.path "u8" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::ImmBorrowLoc",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::ImmBorrowLoc",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "u8",
                                  [ Ty.path "u8" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MutBorrowField",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MutBorrowField",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "move_binary_format::normalized::FieldRef",
                                  [ Ty.path "move_binary_format::normalized::FieldRef" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MutBorrowFieldGeneric",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MutBorrowFieldGeneric",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.tuple
                                    [
                                      Ty.path "move_binary_format::normalized::FieldRef";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [
                                    Ty.tuple
                                      [
                                        Ty.path "move_binary_format::normalized::FieldRef";
                                        Ty.apply
                                          (Ty.path "alloc::vec::Vec")
                                          []
                                          [
                                            Ty.path "move_binary_format::normalized::Type";
                                            Ty.path "alloc::alloc::Global"
                                          ]
                                      ]
                                  ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::ImmBorrowField",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::ImmBorrowField",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "move_binary_format::normalized::FieldRef",
                                  [ Ty.path "move_binary_format::normalized::FieldRef" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::ImmBorrowFieldGeneric",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::ImmBorrowFieldGeneric",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.tuple
                                    [
                                      Ty.path "move_binary_format::normalized::FieldRef";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [
                                    Ty.tuple
                                      [
                                        Ty.path "move_binary_format::normalized::FieldRef";
                                        Ty.apply
                                          (Ty.path "alloc::vec::Vec")
                                          []
                                          [
                                            Ty.path "move_binary_format::normalized::Type";
                                            Ty.path "alloc::alloc::Global"
                                          ]
                                      ]
                                  ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecPack",
                                0
                              |) in
                            let γ2_1 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecPack",
                                1
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let __self_1 := M.alloc (| γ2_1 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecPack",
                                0
                              |) in
                            let γ2_1 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecPack",
                                1
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            let __arg1_1 := M.alloc (| γ2_1 |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    Ty.path "move_binary_format::normalized::Type",
                                    [ Ty.path "move_binary_format::normalized::Type" ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [ M.read (| __self_0 |); M.read (| __arg1_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",
                                          Ty.path "u64",
                                          [ Ty.path "u64" ],
                                          "partial_cmp",
                                          []
                                        |),
                                        [ M.read (| __self_1 |); M.read (| __arg1_1 |) ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let cmp := M.copy (| γ |) in
                                    cmp))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecLen",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecLen",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "move_binary_format::normalized::Type",
                                  [ Ty.path "move_binary_format::normalized::Type" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecImmBorrow",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecImmBorrow",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "move_binary_format::normalized::Type",
                                  [ Ty.path "move_binary_format::normalized::Type" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecMutBorrow",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecMutBorrow",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "move_binary_format::normalized::Type",
                                  [ Ty.path "move_binary_format::normalized::Type" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecPushBack",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecPushBack",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "move_binary_format::normalized::Type",
                                  [ Ty.path "move_binary_format::normalized::Type" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecPopBack",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecPopBack",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "move_binary_format::normalized::Type",
                                  [ Ty.path "move_binary_format::normalized::Type" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecUnpack",
                                0
                              |) in
                            let γ2_1 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecUnpack",
                                1
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let __self_1 := M.alloc (| γ2_1 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecUnpack",
                                0
                              |) in
                            let γ2_1 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecUnpack",
                                1
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            let __arg1_1 := M.alloc (| γ2_1 |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    Ty.path "move_binary_format::normalized::Type",
                                    [ Ty.path "move_binary_format::normalized::Type" ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [ M.read (| __self_0 |); M.read (| __arg1_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",
                                          Ty.path "u64",
                                          [ Ty.path "u64" ],
                                          "partial_cmp",
                                          []
                                        |),
                                        [ M.read (| __self_1 |); M.read (| __arg1_1 |) ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let cmp := M.copy (| γ |) in
                                    cmp))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecSwap",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecSwap",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "move_binary_format::normalized::Type",
                                  [ Ty.path "move_binary_format::normalized::Type" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::LdU16",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::LdU16",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "u16",
                                  [ Ty.path "u16" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::LdU32",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::LdU32",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "u32",
                                  [ Ty.path "u32" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::LdU256",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::LdU256",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "move_core_types::u256::U256",
                                  [ Ty.path "move_core_types::u256::U256" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MutBorrowGlobalDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MutBorrowGlobalDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "move_core_types::identifier::Identifier",
                                  [ Ty.path "move_core_types::identifier::Identifier" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MutBorrowGlobalGenericDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MutBorrowGlobalGenericDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.tuple
                                    [
                                      Ty.path "move_core_types::identifier::Identifier";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [
                                    Ty.tuple
                                      [
                                        Ty.path "move_core_types::identifier::Identifier";
                                        Ty.apply
                                          (Ty.path "alloc::vec::Vec")
                                          []
                                          [
                                            Ty.path "move_binary_format::normalized::Type";
                                            Ty.path "alloc::alloc::Global"
                                          ]
                                      ]
                                  ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::ImmBorrowGlobalDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::ImmBorrowGlobalDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "move_core_types::identifier::Identifier",
                                  [ Ty.path "move_core_types::identifier::Identifier" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::ImmBorrowGlobalGenericDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::ImmBorrowGlobalGenericDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.tuple
                                    [
                                      Ty.path "move_core_types::identifier::Identifier";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [
                                    Ty.tuple
                                      [
                                        Ty.path "move_core_types::identifier::Identifier";
                                        Ty.apply
                                          (Ty.path "alloc::vec::Vec")
                                          []
                                          [
                                            Ty.path "move_binary_format::normalized::Type";
                                            Ty.path "alloc::alloc::Global"
                                          ]
                                      ]
                                  ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::ExistsDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::ExistsDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "move_core_types::identifier::Identifier",
                                  [ Ty.path "move_core_types::identifier::Identifier" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::ExistsGenericDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::ExistsGenericDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.tuple
                                    [
                                      Ty.path "move_core_types::identifier::Identifier";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [
                                    Ty.tuple
                                      [
                                        Ty.path "move_core_types::identifier::Identifier";
                                        Ty.apply
                                          (Ty.path "alloc::vec::Vec")
                                          []
                                          [
                                            Ty.path "move_binary_format::normalized::Type";
                                            Ty.path "alloc::alloc::Global"
                                          ]
                                      ]
                                  ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MoveFromDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MoveFromDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "move_core_types::identifier::Identifier",
                                  [ Ty.path "move_core_types::identifier::Identifier" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MoveFromGenericDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MoveFromGenericDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.tuple
                                    [
                                      Ty.path "move_core_types::identifier::Identifier";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [
                                    Ty.tuple
                                      [
                                        Ty.path "move_core_types::identifier::Identifier";
                                        Ty.apply
                                          (Ty.path "alloc::vec::Vec")
                                          []
                                          [
                                            Ty.path "move_binary_format::normalized::Type";
                                            Ty.path "alloc::alloc::Global"
                                          ]
                                      ]
                                  ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MoveToDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MoveToDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.path "move_core_types::identifier::Identifier",
                                  [ Ty.path "move_core_types::identifier::Identifier" ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MoveToGenericDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MoveToGenericDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  Ty.tuple
                                    [
                                      Ty.path "move_core_types::identifier::Identifier";
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::normalized::Type";
                                          Ty.path "alloc::alloc::Global"
                                        ]
                                    ],
                                  [
                                    Ty.tuple
                                      [
                                        Ty.path "move_core_types::identifier::Identifier";
                                        Ty.apply
                                          (Ty.path "alloc::vec::Vec")
                                          []
                                          [
                                            Ty.path "move_binary_format::normalized::Type";
                                            Ty.path "alloc::alloc::Global"
                                          ]
                                      ]
                                  ],
                                  "partial_cmp",
                                  []
                                |),
                                [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (M.alloc (|
                              Value.StructTuple
                                "core::option::Option::Some"
                                [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                            |)))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let cmp := M.copy (| γ |) in
                    cmp))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::PartialOrd"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("partial_cmp", InstanceField.Method partial_cmp) ].
  End Impl_core_cmp_PartialOrd_for_move_binary_format_normalized_Bytecode.
  
  Module Impl_core_cmp_Eq_for_move_binary_format_normalized_Bytecode.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Bytecode".
    
    (* Eq *)
    Definition assert_receiver_is_total_eq
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.read (|
            M.match_operator (|
              Value.DeclaredButUndefined,
              [
                fun γ =>
                  ltac:(M.monadic
                    (M.match_operator (|
                      Value.DeclaredButUndefined,
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              Value.DeclaredButUndefined,
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (M.match_operator (|
                                      Value.DeclaredButUndefined,
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.match_operator (|
                                              Value.DeclaredButUndefined,
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (M.match_operator (|
                                                      Value.DeclaredButUndefined,
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (M.match_operator (|
                                                              Value.DeclaredButUndefined,
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (M.match_operator (|
                                                                      Value.DeclaredButUndefined,
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (M.match_operator (|
                                                                              Value.DeclaredButUndefined,
                                                                              [
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (M.match_operator (|
                                                                                      Value.DeclaredButUndefined,
                                                                                      [
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (M.match_operator (|
                                                                                              Value.DeclaredButUndefined,
                                                                                              [
                                                                                                fun
                                                                                                    γ =>
                                                                                                  ltac:(M.monadic
                                                                                                    (M.match_operator (|
                                                                                                      Value.DeclaredButUndefined,
                                                                                                      [
                                                                                                        fun
                                                                                                            γ =>
                                                                                                          ltac:(M.monadic
                                                                                                            (M.match_operator (|
                                                                                                              Value.DeclaredButUndefined,
                                                                                                              [
                                                                                                                fun
                                                                                                                    γ =>
                                                                                                                  ltac:(M.monadic
                                                                                                                    (M.match_operator (|
                                                                                                                      Value.DeclaredButUndefined,
                                                                                                                      [
                                                                                                                        fun
                                                                                                                            γ =>
                                                                                                                          ltac:(M.monadic
                                                                                                                            (M.match_operator (|
                                                                                                                              Value.DeclaredButUndefined,
                                                                                                                              [
                                                                                                                                fun
                                                                                                                                    γ =>
                                                                                                                                  ltac:(M.monadic
                                                                                                                                    (M.match_operator (|
                                                                                                                                      Value.DeclaredButUndefined,
                                                                                                                                      [
                                                                                                                                        fun
                                                                                                                                            γ =>
                                                                                                                                          ltac:(M.monadic
                                                                                                                                            (M.match_operator (|
                                                                                                                                              Value.DeclaredButUndefined,
                                                                                                                                              [
                                                                                                                                                fun
                                                                                                                                                    γ =>
                                                                                                                                                  ltac:(M.monadic
                                                                                                                                                    (M.match_operator (|
                                                                                                                                                      Value.DeclaredButUndefined,
                                                                                                                                                      [
                                                                                                                                                        fun
                                                                                                                                                            γ =>
                                                                                                                                                          ltac:(M.monadic
                                                                                                                                                            (M.match_operator (|
                                                                                                                                                              Value.DeclaredButUndefined,
                                                                                                                                                              [
                                                                                                                                                                fun
                                                                                                                                                                    γ =>
                                                                                                                                                                  ltac:(M.monadic
                                                                                                                                                                    (M.match_operator (|
                                                                                                                                                                      Value.DeclaredButUndefined,
                                                                                                                                                                      [
                                                                                                                                                                        fun
                                                                                                                                                                            γ =>
                                                                                                                                                                          ltac:(M.monadic
                                                                                                                                                                            (M.match_operator (|
                                                                                                                                                                              Value.DeclaredButUndefined,
                                                                                                                                                                              [
                                                                                                                                                                                fun
                                                                                                                                                                                    γ =>
                                                                                                                                                                                  ltac:(M.monadic
                                                                                                                                                                                    (M.match_operator (|
                                                                                                                                                                                      Value.DeclaredButUndefined,
                                                                                                                                                                                      [
                                                                                                                                                                                        fun
                                                                                                                                                                                            γ =>
                                                                                                                                                                                          ltac:(M.monadic
                                                                                                                                                                                            (M.match_operator (|
                                                                                                                                                                                              Value.DeclaredButUndefined,
                                                                                                                                                                                              [
                                                                                                                                                                                                fun
                                                                                                                                                                                                    γ =>
                                                                                                                                                                                                  ltac:(M.monadic
                                                                                                                                                                                                    (M.alloc (|
                                                                                                                                                                                                      Value.Tuple
                                                                                                                                                                                                        []
                                                                                                                                                                                                    |)))
                                                                                                                                                                                              ]
                                                                                                                                                                                            |)))
                                                                                                                                                                                      ]
                                                                                                                                                                                    |)))
                                                                                                                                                                              ]
                                                                                                                                                                            |)))
                                                                                                                                                                      ]
                                                                                                                                                                    |)))
                                                                                                                                                              ]
                                                                                                                                                            |)))
                                                                                                                                                      ]
                                                                                                                                                    |)))
                                                                                                                                              ]
                                                                                                                                            |)))
                                                                                                                                      ]
                                                                                                                                    |)))
                                                                                                                              ]
                                                                                                                            |)))
                                                                                                                      ]
                                                                                                                    |)))
                                                                                                              ]
                                                                                                            |)))
                                                                                                      ]
                                                                                                    |)))
                                                                                              ]
                                                                                            |)))
                                                                                      ]
                                                                                    |)))
                                                                              ]
                                                                            |)))
                                                                      ]
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::Eq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *)
        [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ].
  End Impl_core_cmp_Eq_for_move_binary_format_normalized_Bytecode.
  
  Module Impl_core_marker_StructuralPartialEq_for_move_binary_format_normalized_Bytecode.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Bytecode".
    
    Axiom Implements :
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_move_binary_format_normalized_Bytecode.
  
  Module Impl_core_cmp_PartialEq_for_move_binary_format_normalized_Bytecode.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Bytecode".
    
    (* PartialEq *)
    Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ __self_discr :=
              M.alloc (|
                M.call_closure (|
                  M.get_function (|
                    "core::intrinsics::discriminant_value",
                    [ Ty.path "move_binary_format::normalized::Bytecode" ]
                  |),
                  [ M.read (| self |) ]
                |)
              |) in
            let~ __arg1_discr :=
              M.alloc (|
                M.call_closure (|
                  M.get_function (|
                    "core::intrinsics::discriminant_value",
                    [ Ty.path "move_binary_format::normalized::Bytecode" ]
                  |),
                  [ M.read (| other |) ]
                |)
              |) in
            M.alloc (|
              LogicalOp.and (|
                BinOp.eq (| M.read (| __self_discr |), M.read (| __arg1_discr |) |),
                ltac:(M.monadic
                  (M.read (|
                    M.match_operator (|
                      M.alloc (| Value.Tuple [ M.read (| self |); M.read (| other |) ] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::BrTrue",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::BrTrue",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply (Ty.path "&") [] [ Ty.path "u16" ],
                                  [ Ty.apply (Ty.path "&") [] [ Ty.path "u16" ] ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::BrFalse",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::BrFalse",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply (Ty.path "&") [] [ Ty.path "u16" ],
                                  [ Ty.apply (Ty.path "&") [] [ Ty.path "u16" ] ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::Branch",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::Branch",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply (Ty.path "&") [] [ Ty.path "u16" ],
                                  [ Ty.apply (Ty.path "&") [] [ Ty.path "u16" ] ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::LdU8",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::LdU8",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply (Ty.path "&") [] [ Ty.path "u8" ],
                                  [ Ty.apply (Ty.path "&") [] [ Ty.path "u8" ] ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::LdU64",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::LdU64",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply (Ty.path "&") [] [ Ty.path "u64" ],
                                  [ Ty.apply (Ty.path "&") [] [ Ty.path "u64" ] ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::LdU128",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::LdU128",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply (Ty.path "&") [] [ Ty.path "u128" ],
                                  [ Ty.apply (Ty.path "&") [] [ Ty.path "u128" ] ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::LdConst",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::LdConst",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_binary_format::normalized::Constant" ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_binary_format::normalized::Constant" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::CopyLoc",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::CopyLoc",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply (Ty.path "&") [] [ Ty.path "u8" ],
                                  [ Ty.apply (Ty.path "&") [] [ Ty.path "u8" ] ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MoveLoc",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MoveLoc",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply (Ty.path "&") [] [ Ty.path "u8" ],
                                  [ Ty.apply (Ty.path "&") [] [ Ty.path "u8" ] ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::StLoc",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::StLoc",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply (Ty.path "&") [] [ Ty.path "u8" ],
                                  [ Ty.apply (Ty.path "&") [] [ Ty.path "u8" ] ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::Call",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::Call",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_binary_format::normalized::FunctionRef" ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_binary_format::normalized::FunctionRef" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::CallGeneric",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::CallGeneric",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [
                                      Ty.tuple
                                        [
                                          Ty.path "move_binary_format::normalized::FunctionRef";
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path "move_binary_format::normalized::Type";
                                              Ty.path "alloc::alloc::Global"
                                            ]
                                        ]
                                    ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [
                                        Ty.tuple
                                          [
                                            Ty.path "move_binary_format::normalized::FunctionRef";
                                            Ty.apply
                                              (Ty.path "alloc::vec::Vec")
                                              []
                                              [
                                                Ty.path "move_binary_format::normalized::Type";
                                                Ty.path "alloc::alloc::Global"
                                              ]
                                          ]
                                      ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::Pack",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::Pack",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_core_types::identifier::Identifier" ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_core_types::identifier::Identifier" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::PackGeneric",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::PackGeneric",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [
                                      Ty.tuple
                                        [
                                          Ty.path "move_core_types::identifier::Identifier";
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path "move_binary_format::normalized::Type";
                                              Ty.path "alloc::alloc::Global"
                                            ]
                                        ]
                                    ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [
                                        Ty.tuple
                                          [
                                            Ty.path "move_core_types::identifier::Identifier";
                                            Ty.apply
                                              (Ty.path "alloc::vec::Vec")
                                              []
                                              [
                                                Ty.path "move_binary_format::normalized::Type";
                                                Ty.path "alloc::alloc::Global"
                                              ]
                                          ]
                                      ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::Unpack",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::Unpack",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_core_types::identifier::Identifier" ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_core_types::identifier::Identifier" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::UnpackGeneric",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::UnpackGeneric",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [
                                      Ty.tuple
                                        [
                                          Ty.path "move_core_types::identifier::Identifier";
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path "move_binary_format::normalized::Type";
                                              Ty.path "alloc::alloc::Global"
                                            ]
                                        ]
                                    ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [
                                        Ty.tuple
                                          [
                                            Ty.path "move_core_types::identifier::Identifier";
                                            Ty.apply
                                              (Ty.path "alloc::vec::Vec")
                                              []
                                              [
                                                Ty.path "move_binary_format::normalized::Type";
                                                Ty.path "alloc::alloc::Global"
                                              ]
                                          ]
                                      ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MutBorrowLoc",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MutBorrowLoc",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply (Ty.path "&") [] [ Ty.path "u8" ],
                                  [ Ty.apply (Ty.path "&") [] [ Ty.path "u8" ] ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::ImmBorrowLoc",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::ImmBorrowLoc",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply (Ty.path "&") [] [ Ty.path "u8" ],
                                  [ Ty.apply (Ty.path "&") [] [ Ty.path "u8" ] ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MutBorrowField",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MutBorrowField",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_binary_format::normalized::FieldRef" ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_binary_format::normalized::FieldRef" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MutBorrowFieldGeneric",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MutBorrowFieldGeneric",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [
                                      Ty.tuple
                                        [
                                          Ty.path "move_binary_format::normalized::FieldRef";
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path "move_binary_format::normalized::Type";
                                              Ty.path "alloc::alloc::Global"
                                            ]
                                        ]
                                    ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [
                                        Ty.tuple
                                          [
                                            Ty.path "move_binary_format::normalized::FieldRef";
                                            Ty.apply
                                              (Ty.path "alloc::vec::Vec")
                                              []
                                              [
                                                Ty.path "move_binary_format::normalized::Type";
                                                Ty.path "alloc::alloc::Global"
                                              ]
                                          ]
                                      ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::ImmBorrowField",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::ImmBorrowField",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_binary_format::normalized::FieldRef" ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_binary_format::normalized::FieldRef" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::ImmBorrowFieldGeneric",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::ImmBorrowFieldGeneric",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [
                                      Ty.tuple
                                        [
                                          Ty.path "move_binary_format::normalized::FieldRef";
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path "move_binary_format::normalized::Type";
                                              Ty.path "alloc::alloc::Global"
                                            ]
                                        ]
                                    ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [
                                        Ty.tuple
                                          [
                                            Ty.path "move_binary_format::normalized::FieldRef";
                                            Ty.apply
                                              (Ty.path "alloc::vec::Vec")
                                              []
                                              [
                                                Ty.path "move_binary_format::normalized::Type";
                                                Ty.path "alloc::alloc::Global"
                                              ]
                                          ]
                                      ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecPack",
                                0
                              |) in
                            let γ2_1 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecPack",
                                1
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let __self_1 := M.alloc (| γ2_1 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecPack",
                                0
                              |) in
                            let γ2_1 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecPack",
                                1
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            let __arg1_1 := M.alloc (| γ2_1 |) in
                            M.alloc (|
                              LogicalOp.and (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialEq",
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_binary_format::normalized::Type" ],
                                    [
                                      Ty.apply
                                        (Ty.path "&")
                                        []
                                        [ Ty.path "move_binary_format::normalized::Type" ]
                                    ],
                                    "eq",
                                    []
                                  |),
                                  [ __self_0; __arg1_0 ]
                                |),
                                ltac:(M.monadic
                                  (M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply (Ty.path "&") [] [ Ty.path "u64" ],
                                      [ Ty.apply (Ty.path "&") [] [ Ty.path "u64" ] ],
                                      "eq",
                                      []
                                    |),
                                    [ __self_1; __arg1_1 ]
                                  |)))
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecLen",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecLen",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_binary_format::normalized::Type" ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_binary_format::normalized::Type" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecImmBorrow",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecImmBorrow",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_binary_format::normalized::Type" ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_binary_format::normalized::Type" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecMutBorrow",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecMutBorrow",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_binary_format::normalized::Type" ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_binary_format::normalized::Type" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecPushBack",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecPushBack",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_binary_format::normalized::Type" ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_binary_format::normalized::Type" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecPopBack",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecPopBack",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_binary_format::normalized::Type" ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_binary_format::normalized::Type" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecUnpack",
                                0
                              |) in
                            let γ2_1 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecUnpack",
                                1
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let __self_1 := M.alloc (| γ2_1 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecUnpack",
                                0
                              |) in
                            let γ2_1 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecUnpack",
                                1
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            let __arg1_1 := M.alloc (| γ2_1 |) in
                            M.alloc (|
                              LogicalOp.and (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialEq",
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_binary_format::normalized::Type" ],
                                    [
                                      Ty.apply
                                        (Ty.path "&")
                                        []
                                        [ Ty.path "move_binary_format::normalized::Type" ]
                                    ],
                                    "eq",
                                    []
                                  |),
                                  [ __self_0; __arg1_0 ]
                                |),
                                ltac:(M.monadic
                                  (M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply (Ty.path "&") [] [ Ty.path "u64" ],
                                      [ Ty.apply (Ty.path "&") [] [ Ty.path "u64" ] ],
                                      "eq",
                                      []
                                    |),
                                    [ __self_1; __arg1_1 ]
                                  |)))
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::VecSwap",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::VecSwap",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_binary_format::normalized::Type" ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_binary_format::normalized::Type" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::LdU16",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::LdU16",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply (Ty.path "&") [] [ Ty.path "u16" ],
                                  [ Ty.apply (Ty.path "&") [] [ Ty.path "u16" ] ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::LdU32",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::LdU32",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply (Ty.path "&") [] [ Ty.path "u32" ],
                                  [ Ty.apply (Ty.path "&") [] [ Ty.path "u32" ] ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::LdU256",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::LdU256",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_core_types::u256::U256" ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_core_types::u256::U256" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MutBorrowGlobalDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MutBorrowGlobalDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_core_types::identifier::Identifier" ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_core_types::identifier::Identifier" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MutBorrowGlobalGenericDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MutBorrowGlobalGenericDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [
                                      Ty.tuple
                                        [
                                          Ty.path "move_core_types::identifier::Identifier";
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path "move_binary_format::normalized::Type";
                                              Ty.path "alloc::alloc::Global"
                                            ]
                                        ]
                                    ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [
                                        Ty.tuple
                                          [
                                            Ty.path "move_core_types::identifier::Identifier";
                                            Ty.apply
                                              (Ty.path "alloc::vec::Vec")
                                              []
                                              [
                                                Ty.path "move_binary_format::normalized::Type";
                                                Ty.path "alloc::alloc::Global"
                                              ]
                                          ]
                                      ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::ImmBorrowGlobalDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::ImmBorrowGlobalDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_core_types::identifier::Identifier" ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_core_types::identifier::Identifier" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::ImmBorrowGlobalGenericDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::ImmBorrowGlobalGenericDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [
                                      Ty.tuple
                                        [
                                          Ty.path "move_core_types::identifier::Identifier";
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path "move_binary_format::normalized::Type";
                                              Ty.path "alloc::alloc::Global"
                                            ]
                                        ]
                                    ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [
                                        Ty.tuple
                                          [
                                            Ty.path "move_core_types::identifier::Identifier";
                                            Ty.apply
                                              (Ty.path "alloc::vec::Vec")
                                              []
                                              [
                                                Ty.path "move_binary_format::normalized::Type";
                                                Ty.path "alloc::alloc::Global"
                                              ]
                                          ]
                                      ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::ExistsDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::ExistsDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_core_types::identifier::Identifier" ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_core_types::identifier::Identifier" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::ExistsGenericDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::ExistsGenericDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [
                                      Ty.tuple
                                        [
                                          Ty.path "move_core_types::identifier::Identifier";
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path "move_binary_format::normalized::Type";
                                              Ty.path "alloc::alloc::Global"
                                            ]
                                        ]
                                    ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [
                                        Ty.tuple
                                          [
                                            Ty.path "move_core_types::identifier::Identifier";
                                            Ty.apply
                                              (Ty.path "alloc::vec::Vec")
                                              []
                                              [
                                                Ty.path "move_binary_format::normalized::Type";
                                                Ty.path "alloc::alloc::Global"
                                              ]
                                          ]
                                      ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MoveFromDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MoveFromDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_core_types::identifier::Identifier" ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_core_types::identifier::Identifier" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MoveFromGenericDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MoveFromGenericDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [
                                      Ty.tuple
                                        [
                                          Ty.path "move_core_types::identifier::Identifier";
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path "move_binary_format::normalized::Type";
                                              Ty.path "alloc::alloc::Global"
                                            ]
                                        ]
                                    ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [
                                        Ty.tuple
                                          [
                                            Ty.path "move_core_types::identifier::Identifier";
                                            Ty.apply
                                              (Ty.path "alloc::vec::Vec")
                                              []
                                              [
                                                Ty.path "move_binary_format::normalized::Type";
                                                Ty.path "alloc::alloc::Global"
                                              ]
                                          ]
                                      ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MoveToDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MoveToDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_core_types::identifier::Identifier" ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_core_types::identifier::Identifier" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let γ0_0 := M.read (| γ0_0 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_0,
                                "move_binary_format::normalized::Bytecode::MoveToGenericDeprecated",
                                0
                              |) in
                            let __self_0 := M.alloc (| γ2_0 |) in
                            let γ0_1 := M.read (| γ0_1 |) in
                            let γ2_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ0_1,
                                "move_binary_format::normalized::Bytecode::MoveToGenericDeprecated",
                                0
                              |) in
                            let __arg1_0 := M.alloc (| γ2_0 |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [
                                      Ty.tuple
                                        [
                                          Ty.path "move_core_types::identifier::Identifier";
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path "move_binary_format::normalized::Type";
                                              Ty.path "alloc::alloc::Global"
                                            ]
                                        ]
                                    ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [
                                        Ty.tuple
                                          [
                                            Ty.path "move_core_types::identifier::Identifier";
                                            Ty.apply
                                              (Ty.path "alloc::vec::Vec")
                                              []
                                              [
                                                Ty.path "move_binary_format::normalized::Type";
                                                Ty.path "alloc::alloc::Global"
                                              ]
                                          ]
                                      ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ __self_0; __arg1_0 ]
                              |)
                            |)));
                        fun γ => ltac:(M.monadic (M.alloc (| Value.Bool true |)))
                      ]
                    |)
                  |)))
              |)
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::PartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("eq", InstanceField.Method eq) ].
  End Impl_core_cmp_PartialEq_for_move_binary_format_normalized_Bytecode.
  
  
  
  Module Impl_move_binary_format_normalized_Constant.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Constant".
    
    (*
        pub fn new(m: &CompiledModule, constant: &crate::file_format::Constant) -> Self {
            Self {
                type_: Type::new(m, &constant.type_),
                data: constant.data.clone(),
            }
        }
    *)
    Definition new (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ m; constant ] =>
        ltac:(M.monadic
          (let m := M.alloc (| m |) in
          let constant := M.alloc (| constant |) in
          Value.StructRecord
            "move_binary_format::normalized::Constant"
            [
              ("type_",
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.path "move_binary_format::normalized::Type",
                    "new",
                    []
                  |),
                  [
                    M.read (| m |);
                    M.SubPointer.get_struct_record_field (|
                      M.read (| constant |),
                      "move_binary_format::file_format::Constant",
                      "type_"
                    |)
                  ]
                |));
              ("data",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ],
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| constant |),
                      "move_binary_format::file_format::Constant",
                      "data"
                    |)
                  ]
                |))
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_new : M.IsAssociatedFunction Self "new" new.
  End Impl_move_binary_format_normalized_Constant.
  
  (* StructRecord
    {
      name := "Module";
      const_params := [];
      ty_params := [];
      fields :=
        [
          ("file_format_version", Ty.path "u32");
          ("address", Ty.path "move_core_types::account_address::AccountAddress");
          ("name", Ty.path "move_core_types::identifier::Identifier");
          ("dependencies",
            Ty.apply
              (Ty.path "alloc::vec::Vec")
              []
              [
                Ty.path "move_core_types::language_storage::ModuleId";
                Ty.path "alloc::alloc::Global"
              ]);
          ("friends",
            Ty.apply
              (Ty.path "alloc::vec::Vec")
              []
              [
                Ty.path "move_core_types::language_storage::ModuleId";
                Ty.path "alloc::alloc::Global"
              ]);
          ("structs",
            Ty.apply
              (Ty.path "alloc::collections::btree::map::BTreeMap")
              []
              [
                Ty.path "move_core_types::identifier::Identifier";
                Ty.path "move_binary_format::normalized::Struct";
                Ty.path "alloc::alloc::Global"
              ]);
          ("functions",
            Ty.apply
              (Ty.path "alloc::collections::btree::map::BTreeMap")
              []
              [
                Ty.path "move_core_types::identifier::Identifier";
                Ty.path "move_binary_format::normalized::Function";
                Ty.path "alloc::alloc::Global"
              ]);
          ("constants",
            Ty.apply
              (Ty.path "alloc::vec::Vec")
              []
              [ Ty.path "move_binary_format::normalized::Constant"; Ty.path "alloc::alloc::Global"
              ])
        ];
    } *)
  
  Module Impl_core_clone_Clone_for_move_binary_format_normalized_Module.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Module".
    
    (* Clone *)
    Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          Value.StructRecord
            "move_binary_format::normalized::Module"
            [
              ("file_format_version",
                M.call_closure (|
                  M.get_trait_method (| "core::clone::Clone", Ty.path "u32", [], "clone", [] |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Module",
                      "file_format_version"
                    |)
                  ]
                |));
              ("address",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.path "move_core_types::account_address::AccountAddress",
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Module",
                      "address"
                    |)
                  ]
                |));
              ("name",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.path "move_core_types::identifier::Identifier",
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Module",
                      "name"
                    |)
                  ]
                |));
              ("dependencies",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_core_types::language_storage::ModuleId";
                        Ty.path "alloc::alloc::Global"
                      ],
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Module",
                      "dependencies"
                    |)
                  ]
                |));
              ("friends",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_core_types::language_storage::ModuleId";
                        Ty.path "alloc::alloc::Global"
                      ],
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Module",
                      "friends"
                    |)
                  ]
                |));
              ("structs",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.apply
                      (Ty.path "alloc::collections::btree::map::BTreeMap")
                      []
                      [
                        Ty.path "move_core_types::identifier::Identifier";
                        Ty.path "move_binary_format::normalized::Struct";
                        Ty.path "alloc::alloc::Global"
                      ],
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Module",
                      "structs"
                    |)
                  ]
                |));
              ("functions",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.apply
                      (Ty.path "alloc::collections::btree::map::BTreeMap")
                      []
                      [
                        Ty.path "move_core_types::identifier::Identifier";
                        Ty.path "move_binary_format::normalized::Function";
                        Ty.path "alloc::alloc::Global"
                      ],
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Module",
                      "functions"
                    |)
                  ]
                |));
              ("constants",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::normalized::Constant";
                        Ty.path "alloc::alloc::Global"
                      ],
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Module",
                      "constants"
                    |)
                  ]
                |))
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::clone::Clone"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("clone", InstanceField.Method clone) ].
  End Impl_core_clone_Clone_for_move_binary_format_normalized_Module.
  
  Module Impl_core_fmt_Debug_for_move_binary_format_normalized_Module.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Module".
    
    (* Debug *)
    Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; f ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let f := M.alloc (| f |) in
          M.read (|
            let~ names :=
              M.alloc (|
                M.alloc (|
                  Value.Array
                    [
                      M.read (| Value.String "file_format_version" |);
                      M.read (| Value.String "address" |);
                      M.read (| Value.String "name" |);
                      M.read (| Value.String "dependencies" |);
                      M.read (| Value.String "friends" |);
                      M.read (| Value.String "structs" |);
                      M.read (| Value.String "functions" |);
                      M.read (| Value.String "constants" |)
                    ]
                |)
              |) in
            let~ values :=
              M.alloc (|
                M.alloc (|
                  Value.Array
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "move_binary_format::normalized::Module",
                        "file_format_version"
                      |);
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "move_binary_format::normalized::Module",
                        "address"
                      |);
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "move_binary_format::normalized::Module",
                        "name"
                      |);
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "move_binary_format::normalized::Module",
                        "dependencies"
                      |);
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "move_binary_format::normalized::Module",
                        "friends"
                      |);
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "move_binary_format::normalized::Module",
                        "structs"
                      |);
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "move_binary_format::normalized::Module",
                        "functions"
                      |);
                      M.alloc (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "move_binary_format::normalized::Module",
                          "constants"
                        |)
                      |)
                    ]
                |)
              |) in
            M.alloc (|
              M.call_closure (|
                M.get_associated_function (|
                  Ty.path "core::fmt::Formatter",
                  "debug_struct_fields_finish",
                  []
                |),
                [
                  M.read (| f |);
                  M.read (| Value.String "Module" |);
                  M.read (| names |);
                  M.read (| values |)
                ]
              |)
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::fmt::Debug"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
  End Impl_core_fmt_Debug_for_move_binary_format_normalized_Module.
  
  Module Impl_core_cmp_Eq_for_move_binary_format_normalized_Module.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Module".
    
    (* Eq *)
    Definition assert_receiver_is_total_eq
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.read (|
            M.match_operator (|
              Value.DeclaredButUndefined,
              [
                fun γ =>
                  ltac:(M.monadic
                    (M.match_operator (|
                      Value.DeclaredButUndefined,
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              Value.DeclaredButUndefined,
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (M.match_operator (|
                                      Value.DeclaredButUndefined,
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.match_operator (|
                                              Value.DeclaredButUndefined,
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (M.match_operator (|
                                                      Value.DeclaredButUndefined,
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (M.match_operator (|
                                                              Value.DeclaredButUndefined,
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (M.match_operator (|
                                                                      Value.DeclaredButUndefined,
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (M.alloc (|
                                                                              Value.Tuple []
                                                                            |)))
                                                                      ]
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::Eq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *)
        [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ].
  End Impl_core_cmp_Eq_for_move_binary_format_normalized_Module.
  
  Module Impl_core_marker_StructuralPartialEq_for_move_binary_format_normalized_Module.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Module".
    
    Axiom Implements :
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_move_binary_format_normalized_Module.
  
  Module Impl_core_cmp_PartialEq_for_move_binary_format_normalized_Module.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Module".
    
    (* PartialEq *)
    Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.and (|
            LogicalOp.and (|
              LogicalOp.and (|
                LogicalOp.and (|
                  LogicalOp.and (|
                    LogicalOp.and (|
                      LogicalOp.and (|
                        BinOp.eq (|
                          M.read (|
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Module",
                              "file_format_version"
                            |)
                          |),
                          M.read (|
                            M.SubPointer.get_struct_record_field (|
                              M.read (| other |),
                              "move_binary_format::normalized::Module",
                              "file_format_version"
                            |)
                          |)
                        |),
                        ltac:(M.monadic
                          (M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.path "move_core_types::account_address::AccountAddress",
                              [ Ty.path "move_core_types::account_address::AccountAddress" ],
                              "eq",
                              []
                            |),
                            [
                              M.SubPointer.get_struct_record_field (|
                                M.read (| self |),
                                "move_binary_format::normalized::Module",
                                "address"
                              |);
                              M.SubPointer.get_struct_record_field (|
                                M.read (| other |),
                                "move_binary_format::normalized::Module",
                                "address"
                              |)
                            ]
                          |)))
                      |),
                      ltac:(M.monadic
                        (M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialEq",
                            Ty.path "move_core_types::identifier::Identifier",
                            [ Ty.path "move_core_types::identifier::Identifier" ],
                            "eq",
                            []
                          |),
                          [
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "move_binary_format::normalized::Module",
                              "name"
                            |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| other |),
                              "move_binary_format::normalized::Module",
                              "name"
                            |)
                          ]
                        |)))
                    |),
                    ltac:(M.monadic
                      (M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "alloc::vec::Vec")
                            []
                            [
                              Ty.path "move_core_types::language_storage::ModuleId";
                              Ty.path "alloc::alloc::Global"
                            ],
                          [
                            Ty.apply
                              (Ty.path "alloc::vec::Vec")
                              []
                              [
                                Ty.path "move_core_types::language_storage::ModuleId";
                                Ty.path "alloc::alloc::Global"
                              ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| self |),
                            "move_binary_format::normalized::Module",
                            "dependencies"
                          |);
                          M.SubPointer.get_struct_record_field (|
                            M.read (| other |),
                            "move_binary_format::normalized::Module",
                            "dependencies"
                          |)
                        ]
                      |)))
                  |),
                  ltac:(M.monadic
                    (M.call_closure (|
                      M.get_trait_method (|
                        "core::cmp::PartialEq",
                        Ty.apply
                          (Ty.path "alloc::vec::Vec")
                          []
                          [
                            Ty.path "move_core_types::language_storage::ModuleId";
                            Ty.path "alloc::alloc::Global"
                          ],
                        [
                          Ty.apply
                            (Ty.path "alloc::vec::Vec")
                            []
                            [
                              Ty.path "move_core_types::language_storage::ModuleId";
                              Ty.path "alloc::alloc::Global"
                            ]
                        ],
                        "eq",
                        []
                      |),
                      [
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "move_binary_format::normalized::Module",
                          "friends"
                        |);
                        M.SubPointer.get_struct_record_field (|
                          M.read (| other |),
                          "move_binary_format::normalized::Module",
                          "friends"
                        |)
                      ]
                    |)))
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_trait_method (|
                      "core::cmp::PartialEq",
                      Ty.apply
                        (Ty.path "alloc::collections::btree::map::BTreeMap")
                        []
                        [
                          Ty.path "move_core_types::identifier::Identifier";
                          Ty.path "move_binary_format::normalized::Struct";
                          Ty.path "alloc::alloc::Global"
                        ],
                      [
                        Ty.apply
                          (Ty.path "alloc::collections::btree::map::BTreeMap")
                          []
                          [
                            Ty.path "move_core_types::identifier::Identifier";
                            Ty.path "move_binary_format::normalized::Struct";
                            Ty.path "alloc::alloc::Global"
                          ]
                      ],
                      "eq",
                      []
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "move_binary_format::normalized::Module",
                        "structs"
                      |);
                      M.SubPointer.get_struct_record_field (|
                        M.read (| other |),
                        "move_binary_format::normalized::Module",
                        "structs"
                      |)
                    ]
                  |)))
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (|
                    "core::cmp::PartialEq",
                    Ty.apply
                      (Ty.path "alloc::collections::btree::map::BTreeMap")
                      []
                      [
                        Ty.path "move_core_types::identifier::Identifier";
                        Ty.path "move_binary_format::normalized::Function";
                        Ty.path "alloc::alloc::Global"
                      ],
                    [
                      Ty.apply
                        (Ty.path "alloc::collections::btree::map::BTreeMap")
                        []
                        [
                          Ty.path "move_core_types::identifier::Identifier";
                          Ty.path "move_binary_format::normalized::Function";
                          Ty.path "alloc::alloc::Global"
                        ]
                    ],
                    "eq",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_binary_format::normalized::Module",
                      "functions"
                    |);
                    M.SubPointer.get_struct_record_field (|
                      M.read (| other |),
                      "move_binary_format::normalized::Module",
                      "functions"
                    |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (|
                  "core::cmp::PartialEq",
                  Ty.apply
                    (Ty.path "alloc::vec::Vec")
                    []
                    [
                      Ty.path "move_binary_format::normalized::Constant";
                      Ty.path "alloc::alloc::Global"
                    ],
                  [
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::normalized::Constant";
                        Ty.path "alloc::alloc::Global"
                      ]
                  ],
                  "eq",
                  []
                |),
                [
                  M.SubPointer.get_struct_record_field (|
                    M.read (| self |),
                    "move_binary_format::normalized::Module",
                    "constants"
                  |);
                  M.SubPointer.get_struct_record_field (|
                    M.read (| other |),
                    "move_binary_format::normalized::Module",
                    "constants"
                  |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::PartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("eq", InstanceField.Method eq) ].
  End Impl_core_cmp_PartialEq_for_move_binary_format_normalized_Module.
  
  
  
  Module Impl_move_binary_format_normalized_Module.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Module".
    
    (*
        pub fn new(m: &CompiledModule) -> Self {
            let friends = m.immediate_friends();
            let structs = m.struct_defs().iter().map(|d| Struct::new(m, d)).collect();
            let dependencies = m.immediate_dependencies();
            let constants = m
                .constant_pool()
                .iter()
                .map(|constant| Constant::new(m, constant))
                .collect();
            let functions = m
                .function_defs()
                .iter()
                .map(|func_def| Function::new(m, func_def))
                .collect();
            Self {
                file_format_version: m.version(),
                address: *m.address(),
                name: m.name().to_owned(),
                friends,
                structs,
                functions,
                dependencies,
                constants,
            }
        }
    *)
    Definition new (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ m ] =>
        ltac:(M.monadic
          (let m := M.alloc (| m |) in
          M.read (|
            let~ friends :=
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.path "move_binary_format::file_format::CompiledModule",
                    "immediate_friends",
                    []
                  |),
                  [ M.read (| m |) ]
                |)
              |) in
            let~ structs :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (|
                    "core::iter::traits::iterator::Iterator",
                    Ty.apply
                      (Ty.path "core::iter::adapters::map::Map")
                      []
                      [
                        Ty.apply
                          (Ty.path "core::slice::iter::Iter")
                          []
                          [ Ty.path "move_binary_format::file_format::StructDefinition" ];
                        Ty.function
                          [
                            Ty.tuple
                              [
                                Ty.apply
                                  (Ty.path "&")
                                  []
                                  [ Ty.path "move_binary_format::file_format::StructDefinition" ]
                              ]
                          ]
                          (Ty.tuple
                            [
                              Ty.path "move_core_types::identifier::Identifier";
                              Ty.path "move_binary_format::normalized::Struct"
                            ])
                      ],
                    [],
                    "collect",
                    [
                      Ty.apply
                        (Ty.path "alloc::collections::btree::map::BTreeMap")
                        []
                        [
                          Ty.path "move_core_types::identifier::Identifier";
                          Ty.path "move_binary_format::normalized::Struct";
                          Ty.path "alloc::alloc::Global"
                        ]
                    ]
                  |),
                  [
                    M.call_closure (|
                      M.get_trait_method (|
                        "core::iter::traits::iterator::Iterator",
                        Ty.apply
                          (Ty.path "core::slice::iter::Iter")
                          []
                          [ Ty.path "move_binary_format::file_format::StructDefinition" ],
                        [],
                        "map",
                        [
                          Ty.tuple
                            [
                              Ty.path "move_core_types::identifier::Identifier";
                              Ty.path "move_binary_format::normalized::Struct"
                            ];
                          Ty.function
                            [
                              Ty.tuple
                                [
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_binary_format::file_format::StructDefinition" ]
                                ]
                            ]
                            (Ty.tuple
                              [
                                Ty.path "move_core_types::identifier::Identifier";
                                Ty.path "move_binary_format::normalized::Struct"
                              ])
                        ]
                      |),
                      [
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.apply
                              (Ty.path "slice")
                              []
                              [ Ty.path "move_binary_format::file_format::StructDefinition" ],
                            "iter",
                            []
                          |),
                          [
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "struct_defs",
                                []
                              |),
                              [ M.read (| m |) ]
                            |)
                          ]
                        |);
                        M.closure
                          (fun γ =>
                            ltac:(M.monadic
                              match γ with
                              | [ α0 ] =>
                                ltac:(M.monadic
                                  (M.match_operator (|
                                    M.alloc (| α0 |),
                                    [
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let d := M.copy (| γ |) in
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "move_binary_format::normalized::Struct",
                                              "new",
                                              []
                                            |),
                                            [ M.read (| m |); M.read (| d |) ]
                                          |)))
                                    ]
                                  |)))
                              | _ => M.impossible "wrong number of arguments"
                              end))
                      ]
                    |)
                  ]
                |)
              |) in
            let~ dependencies :=
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.path "move_binary_format::file_format::CompiledModule",
                    "immediate_dependencies",
                    []
                  |),
                  [ M.read (| m |) ]
                |)
              |) in
            let~ constants :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (|
                    "core::iter::traits::iterator::Iterator",
                    Ty.apply
                      (Ty.path "core::iter::adapters::map::Map")
                      []
                      [
                        Ty.apply
                          (Ty.path "core::slice::iter::Iter")
                          []
                          [ Ty.path "move_binary_format::file_format::Constant" ];
                        Ty.function
                          [
                            Ty.tuple
                              [
                                Ty.apply
                                  (Ty.path "&")
                                  []
                                  [ Ty.path "move_binary_format::file_format::Constant" ]
                              ]
                          ]
                          (Ty.path "move_binary_format::normalized::Constant")
                      ],
                    [],
                    "collect",
                    [
                      Ty.apply
                        (Ty.path "alloc::vec::Vec")
                        []
                        [
                          Ty.path "move_binary_format::normalized::Constant";
                          Ty.path "alloc::alloc::Global"
                        ]
                    ]
                  |),
                  [
                    M.call_closure (|
                      M.get_trait_method (|
                        "core::iter::traits::iterator::Iterator",
                        Ty.apply
                          (Ty.path "core::slice::iter::Iter")
                          []
                          [ Ty.path "move_binary_format::file_format::Constant" ],
                        [],
                        "map",
                        [
                          Ty.path "move_binary_format::normalized::Constant";
                          Ty.function
                            [
                              Ty.tuple
                                [
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_binary_format::file_format::Constant" ]
                                ]
                            ]
                            (Ty.path "move_binary_format::normalized::Constant")
                        ]
                      |),
                      [
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.apply
                              (Ty.path "slice")
                              []
                              [ Ty.path "move_binary_format::file_format::Constant" ],
                            "iter",
                            []
                          |),
                          [
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "constant_pool",
                                []
                              |),
                              [ M.read (| m |) ]
                            |)
                          ]
                        |);
                        M.closure
                          (fun γ =>
                            ltac:(M.monadic
                              match γ with
                              | [ α0 ] =>
                                ltac:(M.monadic
                                  (M.match_operator (|
                                    M.alloc (| α0 |),
                                    [
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let constant := M.copy (| γ |) in
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "move_binary_format::normalized::Constant",
                                              "new",
                                              []
                                            |),
                                            [ M.read (| m |); M.read (| constant |) ]
                                          |)))
                                    ]
                                  |)))
                              | _ => M.impossible "wrong number of arguments"
                              end))
                      ]
                    |)
                  ]
                |)
              |) in
            let~ functions :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (|
                    "core::iter::traits::iterator::Iterator",
                    Ty.apply
                      (Ty.path "core::iter::adapters::map::Map")
                      []
                      [
                        Ty.apply
                          (Ty.path "core::slice::iter::Iter")
                          []
                          [ Ty.path "move_binary_format::file_format::FunctionDefinition" ];
                        Ty.function
                          [
                            Ty.tuple
                              [
                                Ty.apply
                                  (Ty.path "&")
                                  []
                                  [ Ty.path "move_binary_format::file_format::FunctionDefinition" ]
                              ]
                          ]
                          (Ty.tuple
                            [
                              Ty.path "move_core_types::identifier::Identifier";
                              Ty.path "move_binary_format::normalized::Function"
                            ])
                      ],
                    [],
                    "collect",
                    [
                      Ty.apply
                        (Ty.path "alloc::collections::btree::map::BTreeMap")
                        []
                        [
                          Ty.path "move_core_types::identifier::Identifier";
                          Ty.path "move_binary_format::normalized::Function";
                          Ty.path "alloc::alloc::Global"
                        ]
                    ]
                  |),
                  [
                    M.call_closure (|
                      M.get_trait_method (|
                        "core::iter::traits::iterator::Iterator",
                        Ty.apply
                          (Ty.path "core::slice::iter::Iter")
                          []
                          [ Ty.path "move_binary_format::file_format::FunctionDefinition" ],
                        [],
                        "map",
                        [
                          Ty.tuple
                            [
                              Ty.path "move_core_types::identifier::Identifier";
                              Ty.path "move_binary_format::normalized::Function"
                            ];
                          Ty.function
                            [
                              Ty.tuple
                                [
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_binary_format::file_format::FunctionDefinition"
                                    ]
                                ]
                            ]
                            (Ty.tuple
                              [
                                Ty.path "move_core_types::identifier::Identifier";
                                Ty.path "move_binary_format::normalized::Function"
                              ])
                        ]
                      |),
                      [
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.apply
                              (Ty.path "slice")
                              []
                              [ Ty.path "move_binary_format::file_format::FunctionDefinition" ],
                            "iter",
                            []
                          |),
                          [
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "function_defs",
                                []
                              |),
                              [ M.read (| m |) ]
                            |)
                          ]
                        |);
                        M.closure
                          (fun γ =>
                            ltac:(M.monadic
                              match γ with
                              | [ α0 ] =>
                                ltac:(M.monadic
                                  (M.match_operator (|
                                    M.alloc (| α0 |),
                                    [
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let func_def := M.copy (| γ |) in
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "move_binary_format::normalized::Function",
                                              "new",
                                              []
                                            |),
                                            [ M.read (| m |); M.read (| func_def |) ]
                                          |)))
                                    ]
                                  |)))
                              | _ => M.impossible "wrong number of arguments"
                              end))
                      ]
                    |)
                  ]
                |)
              |) in
            M.alloc (|
              Value.StructRecord
                "move_binary_format::normalized::Module"
                [
                  ("file_format_version",
                    M.call_closure (|
                      M.get_associated_function (|
                        Ty.path "move_binary_format::file_format::CompiledModule",
                        "version",
                        []
                      |),
                      [ M.read (| m |) ]
                    |));
                  ("address",
                    M.read (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "move_binary_format::file_format::CompiledModule",
                          "address",
                          []
                        |),
                        [ M.read (| m |) ]
                      |)
                    |));
                  ("name",
                    M.call_closure (|
                      M.get_trait_method (|
                        "alloc::borrow::ToOwned",
                        Ty.path "move_core_types::identifier::IdentStr",
                        [],
                        "to_owned",
                        []
                      |),
                      [
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "move_binary_format::file_format::CompiledModule",
                            "name",
                            []
                          |),
                          [ M.read (| m |) ]
                        |)
                      ]
                    |));
                  ("friends", M.read (| friends |));
                  ("structs", M.read (| structs |));
                  ("functions", M.read (| functions |));
                  ("dependencies", M.read (| dependencies |));
                  ("constants", M.read (| constants |))
                ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_new : M.IsAssociatedFunction Self "new" new.
    
    (*
        pub fn module_id(&self) -> ModuleId {
            ModuleId::new(self.address, self.name.clone())
        }
    *)
    Definition module_id (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.call_closure (|
            M.get_associated_function (|
              Ty.path "move_core_types::language_storage::ModuleId",
              "new",
              []
            |),
            [
              M.read (|
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "move_binary_format::normalized::Module",
                  "address"
                |)
              |);
              M.call_closure (|
                M.get_trait_method (|
                  "core::clone::Clone",
                  Ty.path "move_core_types::identifier::Identifier",
                  [],
                  "clone",
                  []
                |),
                [
                  M.SubPointer.get_struct_record_field (|
                    M.read (| self |),
                    "move_binary_format::normalized::Module",
                    "name"
                  |)
                ]
              |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_module_id : M.IsAssociatedFunction Self "module_id" module_id.
  End Impl_move_binary_format_normalized_Module.
  
  Module Impl_move_binary_format_normalized_Type.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Type".
    
    (*
        pub fn new(m: &CompiledModule, s: &SignatureToken) -> Self {
            use SignatureToken::*;
            match s {
                Struct(shi) => {
                    let s_handle = m.struct_handle_at( *shi);
                    assert!(s_handle.type_parameters.is_empty(), "A struct with N type parameters should be encoded as StructModuleInstantiation with type_arguments = [TypeParameter(1), ..., TypeParameter(N)]");
                    let m_handle = m.module_handle_at(s_handle.module);
                    Type::Struct {
                        address: *m.address_identifier_at(m_handle.address),
                        module: m.identifier_at(m_handle.name).to_owned(),
                        name: m.identifier_at(s_handle.name).to_owned(),
                        type_arguments: Vec::new(),
                    }
                }
                StructInstantiation(struct_inst) => {
                    let (shi, type_actuals) = &**struct_inst;
                    let s_handle = m.struct_handle_at( *shi);
                    let m_handle = m.module_handle_at(s_handle.module);
                    Type::Struct {
                        address: *m.address_identifier_at(m_handle.address),
                        module: m.identifier_at(m_handle.name).to_owned(),
                        name: m.identifier_at(s_handle.name).to_owned(),
                        type_arguments: type_actuals.iter().map(|t| Type::new(m, t)).collect(),
                    }
                }
                Bool => Type::Bool,
                U8 => Type::U8,
                U16 => Type::U16,
                U32 => Type::U32,
                U64 => Type::U64,
                U128 => Type::U128,
                U256 => Type::U256,
                Address => Type::Address,
                Signer => Type::Signer,
                Vector(t) => Type::Vector(Box::new(Type::new(m, t))),
                TypeParameter(i) => Type::TypeParameter( *i),
                Reference(t) => Type::Reference(Box::new(Type::new(m, t))),
                MutableReference(t) => Type::MutableReference(Box::new(Type::new(m, t))),
            }
        }
    *)
    Definition new (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ m; s ] =>
        ltac:(M.monadic
          (let m := M.alloc (| m |) in
          let s := M.alloc (| s |) in
          M.read (|
            M.match_operator (|
              s,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::SignatureToken::Struct",
                        0
                      |) in
                    let shi := M.alloc (| γ1_0 |) in
                    let~ s_handle :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "move_binary_format::file_format::CompiledModule",
                            "struct_handle_at",
                            []
                          |),
                          [ M.read (| m |); M.read (| M.read (| shi |) |) ]
                        |)
                      |) in
                    let~ _ :=
                      M.match_operator (|
                        M.alloc (| Value.Tuple [] |),
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let γ :=
                                M.use
                                  (M.alloc (|
                                    UnOp.not (|
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::StructTypeParameter";
                                              Ty.path "alloc::alloc::Global"
                                            ],
                                          "is_empty",
                                          []
                                        |),
                                        [
                                          M.SubPointer.get_struct_record_field (|
                                            M.read (| s_handle |),
                                            "move_binary_format::file_format::StructHandle",
                                            "type_parameters"
                                          |)
                                        ]
                                      |)
                                    |)
                                  |)) in
                              let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ |),
                                  Value.Bool true
                                |) in
                              M.alloc (|
                                M.never_to_any (|
                                  M.call_closure (|
                                    M.get_function (| "core::panicking::panic_fmt", [] |),
                                    [
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.path "core::fmt::Arguments",
                                          "new_const",
                                          []
                                        |),
                                        [
                                          M.alloc (|
                                            Value.Array
                                              [
                                                M.read (|
                                                  Value.String
                                                    "A struct with N type parameters should be encoded as StructModuleInstantiation with type_arguments = [TypeParameter(1), ..., TypeParameter(N)]"
                                                |)
                                              ]
                                          |)
                                        ]
                                      |)
                                    ]
                                  |)
                                |)
                              |)));
                          fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                        ]
                      |) in
                    let~ m_handle :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "move_binary_format::file_format::CompiledModule",
                            "module_handle_at",
                            []
                          |),
                          [
                            M.read (| m |);
                            M.read (|
                              M.SubPointer.get_struct_record_field (|
                                M.read (| s_handle |),
                                "move_binary_format::file_format::StructHandle",
                                "module"
                              |)
                            |)
                          ]
                        |)
                      |) in
                    M.alloc (|
                      Value.StructRecord
                        "move_binary_format::normalized::Type::Struct"
                        [
                          ("address",
                            M.read (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::file_format::CompiledModule",
                                  "address_identifier_at",
                                  []
                                |),
                                [
                                  M.read (| m |);
                                  M.read (|
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| m_handle |),
                                      "move_binary_format::file_format::ModuleHandle",
                                      "address"
                                    |)
                                  |)
                                ]
                              |)
                            |));
                          ("module",
                            M.call_closure (|
                              M.get_trait_method (|
                                "alloc::borrow::ToOwned",
                                Ty.path "move_core_types::identifier::IdentStr",
                                [],
                                "to_owned",
                                []
                              |),
                              [
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path "move_binary_format::file_format::CompiledModule",
                                    "identifier_at",
                                    []
                                  |),
                                  [
                                    M.read (| m |);
                                    M.read (|
                                      M.SubPointer.get_struct_record_field (|
                                        M.read (| m_handle |),
                                        "move_binary_format::file_format::ModuleHandle",
                                        "name"
                                      |)
                                    |)
                                  ]
                                |)
                              ]
                            |));
                          ("name",
                            M.call_closure (|
                              M.get_trait_method (|
                                "alloc::borrow::ToOwned",
                                Ty.path "move_core_types::identifier::IdentStr",
                                [],
                                "to_owned",
                                []
                              |),
                              [
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path "move_binary_format::file_format::CompiledModule",
                                    "identifier_at",
                                    []
                                  |),
                                  [
                                    M.read (| m |);
                                    M.read (|
                                      M.SubPointer.get_struct_record_field (|
                                        M.read (| s_handle |),
                                        "move_binary_format::file_format::StructHandle",
                                        "name"
                                      |)
                                    |)
                                  ]
                                |)
                              ]
                            |));
                          ("type_arguments",
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.apply
                                  (Ty.path "alloc::vec::Vec")
                                  []
                                  [
                                    Ty.path "move_binary_format::normalized::Type";
                                    Ty.path "alloc::alloc::Global"
                                  ],
                                "new",
                                []
                              |),
                              []
                            |))
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::SignatureToken::StructInstantiation",
                        0
                      |) in
                    let struct_inst := M.alloc (| γ1_0 |) in
                    M.match_operator (|
                      M.alloc (| M.read (| M.read (| struct_inst |) |) |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ := M.read (| γ |) in
                            let γ1_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                            let γ1_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                            let shi := M.alloc (| γ1_0 |) in
                            let type_actuals := M.alloc (| γ1_1 |) in
                            let~ s_handle :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path "move_binary_format::file_format::CompiledModule",
                                    "struct_handle_at",
                                    []
                                  |),
                                  [ M.read (| m |); M.read (| M.read (| shi |) |) ]
                                |)
                              |) in
                            let~ m_handle :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path "move_binary_format::file_format::CompiledModule",
                                    "module_handle_at",
                                    []
                                  |),
                                  [
                                    M.read (| m |);
                                    M.read (|
                                      M.SubPointer.get_struct_record_field (|
                                        M.read (| s_handle |),
                                        "move_binary_format::file_format::StructHandle",
                                        "module"
                                      |)
                                    |)
                                  ]
                                |)
                              |) in
                            M.alloc (|
                              Value.StructRecord
                                "move_binary_format::normalized::Type::Struct"
                                [
                                  ("address",
                                    M.read (|
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.path "move_binary_format::file_format::CompiledModule",
                                          "address_identifier_at",
                                          []
                                        |),
                                        [
                                          M.read (| m |);
                                          M.read (|
                                            M.SubPointer.get_struct_record_field (|
                                              M.read (| m_handle |),
                                              "move_binary_format::file_format::ModuleHandle",
                                              "address"
                                            |)
                                          |)
                                        ]
                                      |)
                                    |));
                                  ("module",
                                    M.call_closure (|
                                      M.get_trait_method (|
                                        "alloc::borrow::ToOwned",
                                        Ty.path "move_core_types::identifier::IdentStr",
                                        [],
                                        "to_owned",
                                        []
                                      |),
                                      [
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path
                                              "move_binary_format::file_format::CompiledModule",
                                            "identifier_at",
                                            []
                                          |),
                                          [
                                            M.read (| m |);
                                            M.read (|
                                              M.SubPointer.get_struct_record_field (|
                                                M.read (| m_handle |),
                                                "move_binary_format::file_format::ModuleHandle",
                                                "name"
                                              |)
                                            |)
                                          ]
                                        |)
                                      ]
                                    |));
                                  ("name",
                                    M.call_closure (|
                                      M.get_trait_method (|
                                        "alloc::borrow::ToOwned",
                                        Ty.path "move_core_types::identifier::IdentStr",
                                        [],
                                        "to_owned",
                                        []
                                      |),
                                      [
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path
                                              "move_binary_format::file_format::CompiledModule",
                                            "identifier_at",
                                            []
                                          |),
                                          [
                                            M.read (| m |);
                                            M.read (|
                                              M.SubPointer.get_struct_record_field (|
                                                M.read (| s_handle |),
                                                "move_binary_format::file_format::StructHandle",
                                                "name"
                                              |)
                                            |)
                                          ]
                                        |)
                                      ]
                                    |));
                                  ("type_arguments",
                                    M.call_closure (|
                                      M.get_trait_method (|
                                        "core::iter::traits::iterator::Iterator",
                                        Ty.apply
                                          (Ty.path "core::iter::adapters::map::Map")
                                          []
                                          [
                                            Ty.apply
                                              (Ty.path "core::slice::iter::Iter")
                                              []
                                              [
                                                Ty.path
                                                  "move_binary_format::file_format::SignatureToken"
                                              ];
                                            Ty.function
                                              [
                                                Ty.tuple
                                                  [
                                                    Ty.apply
                                                      (Ty.path "&")
                                                      []
                                                      [
                                                        Ty.path
                                                          "move_binary_format::file_format::SignatureToken"
                                                      ]
                                                  ]
                                              ]
                                              (Ty.path "move_binary_format::normalized::Type")
                                          ],
                                        [],
                                        "collect",
                                        [
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path "move_binary_format::normalized::Type";
                                              Ty.path "alloc::alloc::Global"
                                            ]
                                        ]
                                      |),
                                      [
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::iter::traits::iterator::Iterator",
                                            Ty.apply
                                              (Ty.path "core::slice::iter::Iter")
                                              []
                                              [
                                                Ty.path
                                                  "move_binary_format::file_format::SignatureToken"
                                              ],
                                            [],
                                            "map",
                                            [
                                              Ty.path "move_binary_format::normalized::Type";
                                              Ty.function
                                                [
                                                  Ty.tuple
                                                    [
                                                      Ty.apply
                                                        (Ty.path "&")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_binary_format::file_format::SignatureToken"
                                                        ]
                                                    ]
                                                ]
                                                (Ty.path "move_binary_format::normalized::Type")
                                            ]
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.apply
                                                  (Ty.path "slice")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_binary_format::file_format::SignatureToken"
                                                  ],
                                                "iter",
                                                []
                                              |),
                                              [
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::ops::deref::Deref",
                                                    Ty.apply
                                                      (Ty.path "alloc::vec::Vec")
                                                      []
                                                      [
                                                        Ty.path
                                                          "move_binary_format::file_format::SignatureToken";
                                                        Ty.path "alloc::alloc::Global"
                                                      ],
                                                    [],
                                                    "deref",
                                                    []
                                                  |),
                                                  [ M.read (| type_actuals |) ]
                                                |)
                                              ]
                                            |);
                                            M.closure
                                              (fun γ =>
                                                ltac:(M.monadic
                                                  match γ with
                                                  | [ α0 ] =>
                                                    ltac:(M.monadic
                                                      (M.match_operator (|
                                                        M.alloc (| α0 |),
                                                        [
                                                          fun γ =>
                                                            ltac:(M.monadic
                                                              (let t := M.copy (| γ |) in
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "move_binary_format::normalized::Type",
                                                                  "new",
                                                                  []
                                                                |),
                                                                [ M.read (| m |); M.read (| t |) ]
                                                              |)))
                                                        ]
                                                      |)))
                                                  | _ => M.impossible "wrong number of arguments"
                                                  end))
                                          ]
                                        |)
                                      ]
                                    |))
                                ]
                            |)))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::SignatureToken::Bool"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::Bool" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::SignatureToken::U8"
                      |) in
                    M.alloc (| Value.StructTuple "move_binary_format::normalized::Type::U8" [] |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::SignatureToken::U16"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::U16" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::SignatureToken::U32"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::U32" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::SignatureToken::U64"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::U64" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::SignatureToken::U128"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::U128" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::SignatureToken::U256"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::U256" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::SignatureToken::Address"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::Address" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::SignatureToken::Signer"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::Signer" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::SignatureToken::Vector",
                        0
                      |) in
                    let t := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Type::Vector"
                        [
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.apply
                                (Ty.path "alloc::boxed::Box")
                                []
                                [
                                  Ty.path "move_binary_format::normalized::Type";
                                  Ty.path "alloc::alloc::Global"
                                ],
                              "new",
                              []
                            |),
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::normalized::Type",
                                  "new",
                                  []
                                |),
                                [ M.read (| m |); M.read (| M.read (| t |) |) ]
                              |)
                            ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::SignatureToken::TypeParameter",
                        0
                      |) in
                    let i := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Type::TypeParameter"
                        [ M.read (| M.read (| i |) |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::SignatureToken::Reference",
                        0
                      |) in
                    let t := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Type::Reference"
                        [
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.apply
                                (Ty.path "alloc::boxed::Box")
                                []
                                [
                                  Ty.path "move_binary_format::normalized::Type";
                                  Ty.path "alloc::alloc::Global"
                                ],
                              "new",
                              []
                            |),
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::normalized::Type",
                                  "new",
                                  []
                                |),
                                [ M.read (| m |); M.read (| M.read (| t |) |) ]
                              |)
                            ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::SignatureToken::MutableReference",
                        0
                      |) in
                    let t := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Type::MutableReference"
                        [
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.apply
                                (Ty.path "alloc::boxed::Box")
                                []
                                [
                                  Ty.path "move_binary_format::normalized::Type";
                                  Ty.path "alloc::alloc::Global"
                                ],
                              "new",
                              []
                            |),
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::normalized::Type",
                                  "new",
                                  []
                                |),
                                [ M.read (| m |); M.read (| M.read (| t |) |) ]
                              |)
                            ]
                          |)
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_new : M.IsAssociatedFunction Self "new" new.
    
    (*
        pub fn is_closed(&self) -> bool {
            use Type::*;
            match self {
                TypeParameter(_) => false,
                Bool => true,
                U8 => true,
                U16 => true,
                U32 => true,
                U64 => true,
                U128 => true,
                U256 => true,
                Address => true,
                Signer => true,
                Struct { type_arguments, .. } => type_arguments.iter().all(|t| t.is_closed()),
                Vector(t) | Reference(t) | MutableReference(t) => t.is_closed(),
            }
        }
    *)
    Definition is_closed (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.read (|
            M.match_operator (|
              self,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Type::TypeParameter",
                        0
                      |) in
                    M.alloc (| Value.Bool false |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::Bool" |) in
                    M.alloc (| Value.Bool true |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U8" |) in
                    M.alloc (| Value.Bool true |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U16" |) in
                    M.alloc (| Value.Bool true |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U32" |) in
                    M.alloc (| Value.Bool true |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U64" |) in
                    M.alloc (| Value.Bool true |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U128" |) in
                    M.alloc (| Value.Bool true |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U256" |) in
                    M.alloc (| Value.Bool true |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::Address" |) in
                    M.alloc (| Value.Bool true |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::Signer" |) in
                    M.alloc (| Value.Bool true |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_record_field (|
                        γ,
                        "move_binary_format::normalized::Type::Struct",
                        "type_arguments"
                      |) in
                    let type_arguments := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::iter::traits::iterator::Iterator",
                          Ty.apply
                            (Ty.path "core::slice::iter::Iter")
                            []
                            [ Ty.path "move_binary_format::normalized::Type" ],
                          [],
                          "all",
                          [
                            Ty.function
                              [
                                Ty.tuple
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_binary_format::normalized::Type" ]
                                  ]
                              ]
                              (Ty.path "bool")
                          ]
                        |),
                        [
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.apply
                                  (Ty.path "slice")
                                  []
                                  [ Ty.path "move_binary_format::normalized::Type" ],
                                "iter",
                                []
                              |),
                              [
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::ops::deref::Deref",
                                    Ty.apply
                                      (Ty.path "alloc::vec::Vec")
                                      []
                                      [
                                        Ty.path "move_binary_format::normalized::Type";
                                        Ty.path "alloc::alloc::Global"
                                      ],
                                    [],
                                    "deref",
                                    []
                                  |),
                                  [ M.read (| type_arguments |) ]
                                |)
                              ]
                            |)
                          |);
                          M.closure
                            (fun γ =>
                              ltac:(M.monadic
                                match γ with
                                | [ α0 ] =>
                                  ltac:(M.monadic
                                    (M.match_operator (|
                                      M.alloc (| α0 |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let t := M.copy (| γ |) in
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path "move_binary_format::normalized::Type",
                                                "is_closed",
                                                []
                                              |),
                                              [ M.read (| t |) ]
                                            |)))
                                      ]
                                    |)))
                                | _ => M.impossible "wrong number of arguments"
                                end))
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (M.find_or_pattern (|
                      γ,
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ := M.read (| γ |) in
                            let γ1_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "move_binary_format::normalized::Type::Vector",
                                0
                              |) in
                            let t := M.alloc (| γ1_0 |) in
                            Value.Tuple [ t ]));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ := M.read (| γ |) in
                            let γ1_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "move_binary_format::normalized::Type::Reference",
                                0
                              |) in
                            let t := M.alloc (| γ1_0 |) in
                            Value.Tuple [ t ]));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ := M.read (| γ |) in
                            let γ1_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "move_binary_format::normalized::Type::MutableReference",
                                0
                              |) in
                            let t := M.alloc (| γ1_0 |) in
                            Value.Tuple [ t ]))
                      ],
                      M.closure
                        (fun γ =>
                          ltac:(M.monadic
                            match γ with
                            | [ t ] =>
                              ltac:(M.monadic
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::normalized::Type",
                                      "is_closed",
                                      []
                                    |),
                                    [ M.read (| M.read (| t |) |) ]
                                  |)
                                |)))
                            | _ => M.impossible "wrong number of arguments"
                            end))
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_is_closed : M.IsAssociatedFunction Self "is_closed" is_closed.
    
    (*
        pub fn into_type_tag(self) -> Option<TypeTag> {
            use Type::*;
            Some(if self.is_closed() {
                match self {
                    Reference(_) | MutableReference(_) => return None,
                    Bool => TypeTag::Bool,
                    U8 => TypeTag::U8,
                    U16 => TypeTag::U16,
                    U32 => TypeTag::U32,
                    U64 => TypeTag::U64,
                    U128 => TypeTag::U128,
                    U256 => TypeTag::U256,
                    Address => TypeTag::Address,
                    Signer => TypeTag::Signer,
                    Vector(t) => TypeTag::Vector(Box::new(
                        t.into_type_tag()
                            .expect("Invariant violation: vector type argument contains reference"),
                    )),
                    Struct {
                        address,
                        module,
                        name,
                        type_arguments,
                    } => TypeTag::Struct(Box::new(StructTag {
                        address,
                        module,
                        name,
                        type_params: type_arguments
                            .into_iter()
                            .map(|t| {
                                t.into_type_tag().expect(
                                    "Invariant violation: struct type argument contains reference",
                                )
                            })
                            .collect(),
                    })),
                    TypeParameter(_) => unreachable!(),
                }
            } else {
                return None;
            })
        }
    *)
    Definition into_type_tag (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.catch_return (|
            ltac:(M.monadic
              (Value.StructTuple
                "core::option::Option::Some"
                [
                  M.read (|
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::normalized::Type",
                                      "is_closed",
                                      []
                                    |),
                                    [ self ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.match_operator (|
                              self,
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (M.find_or_pattern (|
                                      γ,
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ0_0 :=
                                              M.SubPointer.get_struct_tuple_field (|
                                                γ,
                                                "move_binary_format::normalized::Type::Reference",
                                                0
                                              |) in
                                            Value.Tuple []));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ0_0 :=
                                              M.SubPointer.get_struct_tuple_field (|
                                                γ,
                                                "move_binary_format::normalized::Type::MutableReference",
                                                0
                                              |) in
                                            Value.Tuple []))
                                      ],
                                      M.closure
                                        (fun γ =>
                                          ltac:(M.monadic
                                            match γ with
                                            | [] =>
                                              ltac:(M.monadic
                                                (M.alloc (|
                                                  M.never_to_any (|
                                                    M.read (|
                                                      M.return_ (|
                                                        Value.StructTuple
                                                          "core::option::Option::None"
                                                          []
                                                      |)
                                                    |)
                                                  |)
                                                |)))
                                            | _ => M.impossible "wrong number of arguments"
                                            end))
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (|
                                        γ,
                                        "move_binary_format::normalized::Type::Bool"
                                      |) in
                                    M.alloc (|
                                      Value.StructTuple
                                        "move_core_types::language_storage::TypeTag::Bool"
                                        []
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (|
                                        γ,
                                        "move_binary_format::normalized::Type::U8"
                                      |) in
                                    M.alloc (|
                                      Value.StructTuple
                                        "move_core_types::language_storage::TypeTag::U8"
                                        []
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (|
                                        γ,
                                        "move_binary_format::normalized::Type::U16"
                                      |) in
                                    M.alloc (|
                                      Value.StructTuple
                                        "move_core_types::language_storage::TypeTag::U16"
                                        []
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (|
                                        γ,
                                        "move_binary_format::normalized::Type::U32"
                                      |) in
                                    M.alloc (|
                                      Value.StructTuple
                                        "move_core_types::language_storage::TypeTag::U32"
                                        []
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (|
                                        γ,
                                        "move_binary_format::normalized::Type::U64"
                                      |) in
                                    M.alloc (|
                                      Value.StructTuple
                                        "move_core_types::language_storage::TypeTag::U64"
                                        []
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (|
                                        γ,
                                        "move_binary_format::normalized::Type::U128"
                                      |) in
                                    M.alloc (|
                                      Value.StructTuple
                                        "move_core_types::language_storage::TypeTag::U128"
                                        []
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (|
                                        γ,
                                        "move_binary_format::normalized::Type::U256"
                                      |) in
                                    M.alloc (|
                                      Value.StructTuple
                                        "move_core_types::language_storage::TypeTag::U256"
                                        []
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (|
                                        γ,
                                        "move_binary_format::normalized::Type::Address"
                                      |) in
                                    M.alloc (|
                                      Value.StructTuple
                                        "move_core_types::language_storage::TypeTag::Address"
                                        []
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (|
                                        γ,
                                        "move_binary_format::normalized::Type::Signer"
                                      |) in
                                    M.alloc (|
                                      Value.StructTuple
                                        "move_core_types::language_storage::TypeTag::Signer"
                                        []
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "move_binary_format::normalized::Type::Vector",
                                        0
                                      |) in
                                    let t := M.copy (| γ0_0 |) in
                                    M.alloc (|
                                      Value.StructTuple
                                        "move_core_types::language_storage::TypeTag::Vector"
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.apply
                                                (Ty.path "alloc::boxed::Box")
                                                []
                                                [
                                                  Ty.path
                                                    "move_core_types::language_storage::TypeTag";
                                                  Ty.path "alloc::alloc::Global"
                                                ],
                                              "new",
                                              []
                                            |),
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [
                                                      Ty.path
                                                        "move_core_types::language_storage::TypeTag"
                                                    ],
                                                  "expect",
                                                  []
                                                |),
                                                [
                                                  M.call_closure (|
                                                    M.get_associated_function (|
                                                      Ty.path
                                                        "move_binary_format::normalized::Type",
                                                      "into_type_tag",
                                                      []
                                                    |),
                                                    [ M.read (| M.read (| t |) |) ]
                                                  |);
                                                  M.read (|
                                                    Value.String
                                                      "Invariant violation: vector type argument contains reference"
                                                  |)
                                                ]
                                              |)
                                            ]
                                          |)
                                        ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_record_field (|
                                        γ,
                                        "move_binary_format::normalized::Type::Struct",
                                        "address"
                                      |) in
                                    let γ0_1 :=
                                      M.SubPointer.get_struct_record_field (|
                                        γ,
                                        "move_binary_format::normalized::Type::Struct",
                                        "module"
                                      |) in
                                    let γ0_2 :=
                                      M.SubPointer.get_struct_record_field (|
                                        γ,
                                        "move_binary_format::normalized::Type::Struct",
                                        "name"
                                      |) in
                                    let γ0_3 :=
                                      M.SubPointer.get_struct_record_field (|
                                        γ,
                                        "move_binary_format::normalized::Type::Struct",
                                        "type_arguments"
                                      |) in
                                    let address := M.copy (| γ0_0 |) in
                                    let module := M.copy (| γ0_1 |) in
                                    let name := M.copy (| γ0_2 |) in
                                    let type_arguments := M.copy (| γ0_3 |) in
                                    M.alloc (|
                                      Value.StructTuple
                                        "move_core_types::language_storage::TypeTag::Struct"
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.apply
                                                (Ty.path "alloc::boxed::Box")
                                                []
                                                [
                                                  Ty.path
                                                    "move_core_types::language_storage::StructTag";
                                                  Ty.path "alloc::alloc::Global"
                                                ],
                                              "new",
                                              []
                                            |),
                                            [
                                              Value.StructRecord
                                                "move_core_types::language_storage::StructTag"
                                                [
                                                  ("address", M.read (| address |));
                                                  ("module", M.read (| module |));
                                                  ("name", M.read (| name |));
                                                  ("type_params",
                                                    M.call_closure (|
                                                      M.get_trait_method (|
                                                        "core::iter::traits::iterator::Iterator",
                                                        Ty.apply
                                                          (Ty.path "core::iter::adapters::map::Map")
                                                          []
                                                          [
                                                            Ty.apply
                                                              (Ty.path
                                                                "alloc::vec::into_iter::IntoIter")
                                                              []
                                                              [
                                                                Ty.path
                                                                  "move_binary_format::normalized::Type";
                                                                Ty.path "alloc::alloc::Global"
                                                              ];
                                                            Ty.function
                                                              [
                                                                Ty.tuple
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::normalized::Type"
                                                                  ]
                                                              ]
                                                              (Ty.path
                                                                "move_core_types::language_storage::TypeTag")
                                                          ],
                                                        [],
                                                        "collect",
                                                        [
                                                          Ty.apply
                                                            (Ty.path "alloc::vec::Vec")
                                                            []
                                                            [
                                                              Ty.path
                                                                "move_core_types::language_storage::TypeTag";
                                                              Ty.path "alloc::alloc::Global"
                                                            ]
                                                        ]
                                                      |),
                                                      [
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::iter::traits::iterator::Iterator",
                                                            Ty.apply
                                                              (Ty.path
                                                                "alloc::vec::into_iter::IntoIter")
                                                              []
                                                              [
                                                                Ty.path
                                                                  "move_binary_format::normalized::Type";
                                                                Ty.path "alloc::alloc::Global"
                                                              ],
                                                            [],
                                                            "map",
                                                            [
                                                              Ty.path
                                                                "move_core_types::language_storage::TypeTag";
                                                              Ty.function
                                                                [
                                                                  Ty.tuple
                                                                    [
                                                                      Ty.path
                                                                        "move_binary_format::normalized::Type"
                                                                    ]
                                                                ]
                                                                (Ty.path
                                                                  "move_core_types::language_storage::TypeTag")
                                                            ]
                                                          |),
                                                          [
                                                            M.call_closure (|
                                                              M.get_trait_method (|
                                                                "core::iter::traits::collect::IntoIterator",
                                                                Ty.apply
                                                                  (Ty.path "alloc::vec::Vec")
                                                                  []
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::normalized::Type";
                                                                    Ty.path "alloc::alloc::Global"
                                                                  ],
                                                                [],
                                                                "into_iter",
                                                                []
                                                              |),
                                                              [ M.read (| type_arguments |) ]
                                                            |);
                                                            M.closure
                                                              (fun γ =>
                                                                ltac:(M.monadic
                                                                  match γ with
                                                                  | [ α0 ] =>
                                                                    ltac:(M.monadic
                                                                      (M.match_operator (|
                                                                        M.alloc (| α0 |),
                                                                        [
                                                                          fun γ =>
                                                                            ltac:(M.monadic
                                                                              (let t :=
                                                                                M.copy (| γ |) in
                                                                              M.call_closure (|
                                                                                M.get_associated_function (|
                                                                                  Ty.apply
                                                                                    (Ty.path
                                                                                      "core::option::Option")
                                                                                    []
                                                                                    [
                                                                                      Ty.path
                                                                                        "move_core_types::language_storage::TypeTag"
                                                                                    ],
                                                                                  "expect",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  M.call_closure (|
                                                                                    M.get_associated_function (|
                                                                                      Ty.path
                                                                                        "move_binary_format::normalized::Type",
                                                                                      "into_type_tag",
                                                                                      []
                                                                                    |),
                                                                                    [ M.read (| t |)
                                                                                    ]
                                                                                  |);
                                                                                  M.read (|
                                                                                    Value.String
                                                                                      "Invariant violation: struct type argument contains reference"
                                                                                  |)
                                                                                ]
                                                                              |)))
                                                                        ]
                                                                      |)))
                                                                  | _ =>
                                                                    M.impossible
                                                                      "wrong number of arguments"
                                                                  end))
                                                          ]
                                                        |)
                                                      ]
                                                    |))
                                                ]
                                            ]
                                          |)
                                        ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "move_binary_format::normalized::Type::TypeParameter",
                                        0
                                      |) in
                                    M.alloc (|
                                      M.never_to_any (|
                                        M.call_closure (|
                                          M.get_function (| "core::panicking::panic", [] |),
                                          [
                                            M.read (|
                                              Value.String
                                                "internal error: entered unreachable code"
                                            |)
                                          ]
                                        |)
                                      |)
                                    |)))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (| Value.StructTuple "core::option::Option::None" [] |)
                                |)
                              |)
                            |)))
                      ]
                    |)
                  |)
                ]))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_into_type_tag :
      M.IsAssociatedFunction Self "into_type_tag" into_type_tag.
    
    (*
        pub fn into_struct_tag(self) -> Option<StructTag> {
            match self.into_type_tag()? {
                TypeTag::Struct(s) => Some( *s),
                _ => None,
            }
        }
    *)
    Definition into_struct_tag (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.catch_return (|
            ltac:(M.monadic
              (M.read (|
                M.match_operator (|
                  M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::ops::try_trait::Try",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "move_core_types::language_storage::TypeTag" ],
                          [],
                          "branch",
                          []
                        |),
                        [
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "move_binary_format::normalized::Type",
                              "into_type_tag",
                              []
                            |),
                            [ M.read (| self |) ]
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::ops::control_flow::ControlFlow::Break",
                              0
                            |) in
                          let residual := M.copy (| γ0_0 |) in
                          M.alloc (|
                            M.never_to_any (|
                              M.read (|
                                M.return_ (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::ops::try_trait::FromResidual",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "move_core_types::language_storage::StructTag" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::convert::Infallible" ]
                                      ],
                                      "from_residual",
                                      []
                                    |),
                                    [ M.read (| residual |) ]
                                  |)
                                |)
                              |)
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::ops::control_flow::ControlFlow::Continue",
                              0
                            |) in
                          let val := M.copy (| γ0_0 |) in
                          val))
                    ]
                  |),
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ0_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_core_types::language_storage::TypeTag::Struct",
                            0
                          |) in
                        let s := M.copy (| γ0_0 |) in
                        M.alloc (|
                          Value.StructTuple
                            "core::option::Option::Some"
                            [ M.read (| M.read (| s |) |) ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (M.alloc (| Value.StructTuple "core::option::Option::None" [] |)))
                  ]
                |)
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_into_struct_tag :
      M.IsAssociatedFunction Self "into_struct_tag" into_struct_tag.
    
    (*
        pub fn subst(&self, type_args: &[Type]) -> Self {
            use Type::*;
            match self {
                Bool | U8 | U16 | U32 | U64 | U128 | U256 | Address | Signer => self.clone(),
                Reference(ty) => Reference(Box::new(ty.subst(type_args))),
                MutableReference(ty) => MutableReference(Box::new(ty.subst(type_args))),
                Vector(t) => Vector(Box::new(t.subst(type_args))),
                Struct {
                    address,
                    module,
                    name,
                    type_arguments,
                } => Struct {
                    address: *address,
                    module: module.clone(),
                    name: name.clone(),
                    type_arguments: type_arguments
                        .iter()
                        .map(|t| t.subst(type_args))
                        .collect::<Vec<_>>(),
                },
                TypeParameter(i) => type_args
                    .get( *i as usize)
                    .expect("Type parameter index out of bound")
                    .clone(),
            }
        }
    *)
    Definition subst (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; type_args ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let type_args := M.alloc (| type_args |) in
          M.read (|
            M.match_operator (|
              self,
              [
                fun γ =>
                  ltac:(M.monadic
                    (M.find_or_pattern (|
                      γ,
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ := M.read (| γ |) in
                            let _ :=
                              M.is_struct_tuple (|
                                γ,
                                "move_binary_format::normalized::Type::Bool"
                              |) in
                            Value.Tuple []));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ := M.read (| γ |) in
                            let _ :=
                              M.is_struct_tuple (|
                                γ,
                                "move_binary_format::normalized::Type::U8"
                              |) in
                            Value.Tuple []));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ := M.read (| γ |) in
                            let _ :=
                              M.is_struct_tuple (|
                                γ,
                                "move_binary_format::normalized::Type::U16"
                              |) in
                            Value.Tuple []));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ := M.read (| γ |) in
                            let _ :=
                              M.is_struct_tuple (|
                                γ,
                                "move_binary_format::normalized::Type::U32"
                              |) in
                            Value.Tuple []));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ := M.read (| γ |) in
                            let _ :=
                              M.is_struct_tuple (|
                                γ,
                                "move_binary_format::normalized::Type::U64"
                              |) in
                            Value.Tuple []));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ := M.read (| γ |) in
                            let _ :=
                              M.is_struct_tuple (|
                                γ,
                                "move_binary_format::normalized::Type::U128"
                              |) in
                            Value.Tuple []));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ := M.read (| γ |) in
                            let _ :=
                              M.is_struct_tuple (|
                                γ,
                                "move_binary_format::normalized::Type::U256"
                              |) in
                            Value.Tuple []));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ := M.read (| γ |) in
                            let _ :=
                              M.is_struct_tuple (|
                                γ,
                                "move_binary_format::normalized::Type::Address"
                              |) in
                            Value.Tuple []));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ := M.read (| γ |) in
                            let _ :=
                              M.is_struct_tuple (|
                                γ,
                                "move_binary_format::normalized::Type::Signer"
                              |) in
                            Value.Tuple []))
                      ],
                      M.closure
                        (fun γ =>
                          ltac:(M.monadic
                            match γ with
                            | [] =>
                              ltac:(M.monadic
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::clone::Clone",
                                      Ty.path "move_binary_format::normalized::Type",
                                      [],
                                      "clone",
                                      []
                                    |),
                                    [ M.read (| self |) ]
                                  |)
                                |)))
                            | _ => M.impossible "wrong number of arguments"
                            end))
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Type::Reference",
                        0
                      |) in
                    let ty := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Type::Reference"
                        [
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.apply
                                (Ty.path "alloc::boxed::Box")
                                []
                                [
                                  Ty.path "move_binary_format::normalized::Type";
                                  Ty.path "alloc::alloc::Global"
                                ],
                              "new",
                              []
                            |),
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::normalized::Type",
                                  "subst",
                                  []
                                |),
                                [ M.read (| M.read (| ty |) |); M.read (| type_args |) ]
                              |)
                            ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Type::MutableReference",
                        0
                      |) in
                    let ty := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Type::MutableReference"
                        [
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.apply
                                (Ty.path "alloc::boxed::Box")
                                []
                                [
                                  Ty.path "move_binary_format::normalized::Type";
                                  Ty.path "alloc::alloc::Global"
                                ],
                              "new",
                              []
                            |),
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::normalized::Type",
                                  "subst",
                                  []
                                |),
                                [ M.read (| M.read (| ty |) |); M.read (| type_args |) ]
                              |)
                            ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Type::Vector",
                        0
                      |) in
                    let t := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Type::Vector"
                        [
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.apply
                                (Ty.path "alloc::boxed::Box")
                                []
                                [
                                  Ty.path "move_binary_format::normalized::Type";
                                  Ty.path "alloc::alloc::Global"
                                ],
                              "new",
                              []
                            |),
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::normalized::Type",
                                  "subst",
                                  []
                                |),
                                [ M.read (| M.read (| t |) |); M.read (| type_args |) ]
                              |)
                            ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_record_field (|
                        γ,
                        "move_binary_format::normalized::Type::Struct",
                        "address"
                      |) in
                    let γ1_1 :=
                      M.SubPointer.get_struct_record_field (|
                        γ,
                        "move_binary_format::normalized::Type::Struct",
                        "module"
                      |) in
                    let γ1_2 :=
                      M.SubPointer.get_struct_record_field (|
                        γ,
                        "move_binary_format::normalized::Type::Struct",
                        "name"
                      |) in
                    let γ1_3 :=
                      M.SubPointer.get_struct_record_field (|
                        γ,
                        "move_binary_format::normalized::Type::Struct",
                        "type_arguments"
                      |) in
                    let address := M.alloc (| γ1_0 |) in
                    let module := M.alloc (| γ1_1 |) in
                    let name := M.alloc (| γ1_2 |) in
                    let type_arguments := M.alloc (| γ1_3 |) in
                    M.alloc (|
                      Value.StructRecord
                        "move_binary_format::normalized::Type::Struct"
                        [
                          ("address", M.read (| M.read (| address |) |));
                          ("module",
                            M.call_closure (|
                              M.get_trait_method (|
                                "core::clone::Clone",
                                Ty.path "move_core_types::identifier::Identifier",
                                [],
                                "clone",
                                []
                              |),
                              [ M.read (| module |) ]
                            |));
                          ("name",
                            M.call_closure (|
                              M.get_trait_method (|
                                "core::clone::Clone",
                                Ty.path "move_core_types::identifier::Identifier",
                                [],
                                "clone",
                                []
                              |),
                              [ M.read (| name |) ]
                            |));
                          ("type_arguments",
                            M.call_closure (|
                              M.get_trait_method (|
                                "core::iter::traits::iterator::Iterator",
                                Ty.apply
                                  (Ty.path "core::iter::adapters::map::Map")
                                  []
                                  [
                                    Ty.apply
                                      (Ty.path "core::slice::iter::Iter")
                                      []
                                      [ Ty.path "move_binary_format::normalized::Type" ];
                                    Ty.function
                                      [
                                        Ty.tuple
                                          [
                                            Ty.apply
                                              (Ty.path "&")
                                              []
                                              [ Ty.path "move_binary_format::normalized::Type" ]
                                          ]
                                      ]
                                      (Ty.path "move_binary_format::normalized::Type")
                                  ],
                                [],
                                "collect",
                                [
                                  Ty.apply
                                    (Ty.path "alloc::vec::Vec")
                                    []
                                    [
                                      Ty.path "move_binary_format::normalized::Type";
                                      Ty.path "alloc::alloc::Global"
                                    ]
                                ]
                              |),
                              [
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::iter::traits::iterator::Iterator",
                                    Ty.apply
                                      (Ty.path "core::slice::iter::Iter")
                                      []
                                      [ Ty.path "move_binary_format::normalized::Type" ],
                                    [],
                                    "map",
                                    [
                                      Ty.path "move_binary_format::normalized::Type";
                                      Ty.function
                                        [
                                          Ty.tuple
                                            [
                                              Ty.apply
                                                (Ty.path "&")
                                                []
                                                [ Ty.path "move_binary_format::normalized::Type" ]
                                            ]
                                        ]
                                        (Ty.path "move_binary_format::normalized::Type")
                                    ]
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.apply
                                          (Ty.path "slice")
                                          []
                                          [ Ty.path "move_binary_format::normalized::Type" ],
                                        "iter",
                                        []
                                      |),
                                      [
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::ops::deref::Deref",
                                            Ty.apply
                                              (Ty.path "alloc::vec::Vec")
                                              []
                                              [
                                                Ty.path "move_binary_format::normalized::Type";
                                                Ty.path "alloc::alloc::Global"
                                              ],
                                            [],
                                            "deref",
                                            []
                                          |),
                                          [ M.read (| type_arguments |) ]
                                        |)
                                      ]
                                    |);
                                    M.closure
                                      (fun γ =>
                                        ltac:(M.monadic
                                          match γ with
                                          | [ α0 ] =>
                                            ltac:(M.monadic
                                              (M.match_operator (|
                                                M.alloc (| α0 |),
                                                [
                                                  fun γ =>
                                                    ltac:(M.monadic
                                                      (let t := M.copy (| γ |) in
                                                      M.call_closure (|
                                                        M.get_associated_function (|
                                                          Ty.path
                                                            "move_binary_format::normalized::Type",
                                                          "subst",
                                                          []
                                                        |),
                                                        [ M.read (| t |); M.read (| type_args |) ]
                                                      |)))
                                                ]
                                              |)))
                                          | _ => M.impossible "wrong number of arguments"
                                          end))
                                  ]
                                |)
                              ]
                            |))
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::normalized::Type::TypeParameter",
                        0
                      |) in
                    let i := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::clone::Clone",
                          Ty.path "move_binary_format::normalized::Type",
                          [],
                          "clone",
                          []
                        |),
                        [
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_binary_format::normalized::Type" ]
                                ],
                              "expect",
                              []
                            |),
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.apply
                                    (Ty.path "slice")
                                    []
                                    [ Ty.path "move_binary_format::normalized::Type" ],
                                  "get",
                                  [ Ty.path "usize" ]
                                |),
                                [ M.read (| type_args |); M.rust_cast (M.read (| M.read (| i |) |))
                                ]
                              |);
                              M.read (| Value.String "Type parameter index out of bound" |)
                            ]
                          |)
                        ]
                      |)
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_subst : M.IsAssociatedFunction Self "subst" subst.
  End Impl_move_binary_format_normalized_Type.
  
  Module Impl_move_binary_format_normalized_Field.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Field".
    
    (*
        pub fn new(m: &CompiledModule, f: &FieldDefinition) -> Self {
            Field {
                name: m.identifier_at(f.name).to_owned(),
                type_: Type::new(m, &f.signature.0),
            }
        }
    *)
    Definition new (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ m; f ] =>
        ltac:(M.monadic
          (let m := M.alloc (| m |) in
          let f := M.alloc (| f |) in
          Value.StructRecord
            "move_binary_format::normalized::Field"
            [
              ("name",
                M.call_closure (|
                  M.get_trait_method (|
                    "alloc::borrow::ToOwned",
                    Ty.path "move_core_types::identifier::IdentStr",
                    [],
                    "to_owned",
                    []
                  |),
                  [
                    M.call_closure (|
                      M.get_associated_function (|
                        Ty.path "move_binary_format::file_format::CompiledModule",
                        "identifier_at",
                        []
                      |),
                      [
                        M.read (| m |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| f |),
                            "move_binary_format::file_format::FieldDefinition",
                            "name"
                          |)
                        |)
                      ]
                    |)
                  ]
                |));
              ("type_",
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.path "move_binary_format::normalized::Type",
                    "new",
                    []
                  |),
                  [
                    M.read (| m |);
                    M.SubPointer.get_struct_tuple_field (|
                      M.SubPointer.get_struct_record_field (|
                        M.read (| f |),
                        "move_binary_format::file_format::FieldDefinition",
                        "signature"
                      |),
                      "move_binary_format::file_format::TypeSignature",
                      0
                    |)
                  ]
                |))
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_new : M.IsAssociatedFunction Self "new" new.
  End Impl_move_binary_format_normalized_Field.
  
  Module Impl_move_binary_format_normalized_Struct.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Struct".
    
    (*
        pub fn new(m: &CompiledModule, def: &StructDefinition) -> (Identifier, Self) {
            let handle = m.struct_handle_at(def.struct_handle);
            let fields = match &def.field_information {
                StructFieldInformation::Native => {
                    // Pretend for compatibility checking no fields
                    vec![]
                }
                StructFieldInformation::Declared(fields) => {
                    fields.iter().map(|f| Field::new(m, f)).collect()
                }
            };
            let name = m.identifier_at(handle.name).to_owned();
            let s = Struct {
                abilities: handle.abilities,
                type_parameters: handle.type_parameters.clone(),
                fields,
            };
            (name, s)
        }
    *)
    Definition new (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ m; def ] =>
        ltac:(M.monadic
          (let m := M.alloc (| m |) in
          let def := M.alloc (| def |) in
          M.read (|
            let~ handle :=
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.path "move_binary_format::file_format::CompiledModule",
                    "struct_handle_at",
                    []
                  |),
                  [
                    M.read (| m |);
                    M.read (|
                      M.SubPointer.get_struct_record_field (|
                        M.read (| def |),
                        "move_binary_format::file_format::StructDefinition",
                        "struct_handle"
                      |)
                    |)
                  ]
                |)
              |) in
            let~ fields :=
              M.copy (|
                M.match_operator (|
                  M.alloc (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| def |),
                      "move_binary_format::file_format::StructDefinition",
                      "field_information"
                    |)
                  |),
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (|
                            γ,
                            "move_binary_format::file_format::StructFieldInformation::Native"
                          |) in
                        M.alloc (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.apply
                                (Ty.path "alloc::vec::Vec")
                                []
                                [
                                  Ty.path "move_binary_format::normalized::Field";
                                  Ty.path "alloc::alloc::Global"
                                ],
                              "new",
                              []
                            |),
                            []
                          |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::StructFieldInformation::Declared",
                            0
                          |) in
                        let fields := M.alloc (| γ1_0 |) in
                        M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::iter::traits::iterator::Iterator",
                              Ty.apply
                                (Ty.path "core::iter::adapters::map::Map")
                                []
                                [
                                  Ty.apply
                                    (Ty.path "core::slice::iter::Iter")
                                    []
                                    [ Ty.path "move_binary_format::file_format::FieldDefinition" ];
                                  Ty.function
                                    [
                                      Ty.tuple
                                        [
                                          Ty.apply
                                            (Ty.path "&")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::FieldDefinition"
                                            ]
                                        ]
                                    ]
                                    (Ty.path "move_binary_format::normalized::Field")
                                ],
                              [],
                              "collect",
                              [
                                Ty.apply
                                  (Ty.path "alloc::vec::Vec")
                                  []
                                  [
                                    Ty.path "move_binary_format::normalized::Field";
                                    Ty.path "alloc::alloc::Global"
                                  ]
                              ]
                            |),
                            [
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::iter::traits::iterator::Iterator",
                                  Ty.apply
                                    (Ty.path "core::slice::iter::Iter")
                                    []
                                    [ Ty.path "move_binary_format::file_format::FieldDefinition" ],
                                  [],
                                  "map",
                                  [
                                    Ty.path "move_binary_format::normalized::Field";
                                    Ty.function
                                      [
                                        Ty.tuple
                                          [
                                            Ty.apply
                                              (Ty.path "&")
                                              []
                                              [
                                                Ty.path
                                                  "move_binary_format::file_format::FieldDefinition"
                                              ]
                                          ]
                                      ]
                                      (Ty.path "move_binary_format::normalized::Field")
                                  ]
                                |),
                                [
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.apply
                                        (Ty.path "slice")
                                        []
                                        [ Ty.path "move_binary_format::file_format::FieldDefinition"
                                        ],
                                      "iter",
                                      []
                                    |),
                                    [
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::ops::deref::Deref",
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::FieldDefinition";
                                              Ty.path "alloc::alloc::Global"
                                            ],
                                          [],
                                          "deref",
                                          []
                                        |),
                                        [ M.read (| fields |) ]
                                      |)
                                    ]
                                  |);
                                  M.closure
                                    (fun γ =>
                                      ltac:(M.monadic
                                        match γ with
                                        | [ α0 ] =>
                                          ltac:(M.monadic
                                            (M.match_operator (|
                                              M.alloc (| α0 |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let f := M.copy (| γ |) in
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path
                                                          "move_binary_format::normalized::Field",
                                                        "new",
                                                        []
                                                      |),
                                                      [ M.read (| m |); M.read (| f |) ]
                                                    |)))
                                              ]
                                            |)))
                                        | _ => M.impossible "wrong number of arguments"
                                        end))
                                ]
                              |)
                            ]
                          |)
                        |)))
                  ]
                |)
              |) in
            let~ name :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (|
                    "alloc::borrow::ToOwned",
                    Ty.path "move_core_types::identifier::IdentStr",
                    [],
                    "to_owned",
                    []
                  |),
                  [
                    M.call_closure (|
                      M.get_associated_function (|
                        Ty.path "move_binary_format::file_format::CompiledModule",
                        "identifier_at",
                        []
                      |),
                      [
                        M.read (| m |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| handle |),
                            "move_binary_format::file_format::StructHandle",
                            "name"
                          |)
                        |)
                      ]
                    |)
                  ]
                |)
              |) in
            let~ s :=
              M.alloc (|
                Value.StructRecord
                  "move_binary_format::normalized::Struct"
                  [
                    ("abilities",
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| handle |),
                          "move_binary_format::file_format::StructHandle",
                          "abilities"
                        |)
                      |));
                    ("type_parameters",
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::clone::Clone",
                          Ty.apply
                            (Ty.path "alloc::vec::Vec")
                            []
                            [
                              Ty.path "move_binary_format::file_format::StructTypeParameter";
                              Ty.path "alloc::alloc::Global"
                            ],
                          [],
                          "clone",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| handle |),
                            "move_binary_format::file_format::StructHandle",
                            "type_parameters"
                          |)
                        ]
                      |));
                    ("fields", M.read (| fields |))
                  ]
              |) in
            M.alloc (| Value.Tuple [ M.read (| name |); M.read (| s |) ] |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_new : M.IsAssociatedFunction Self "new" new.
    
    (*
        pub fn from_idx(m: &CompiledModule, idx: &StructDefinitionIndex) -> (Identifier, Self) {
            Self::new(m, m.struct_def_at( *idx))
        }
    *)
    Definition from_idx (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ m; idx ] =>
        ltac:(M.monadic
          (let m := M.alloc (| m |) in
          let idx := M.alloc (| idx |) in
          M.call_closure (|
            M.get_associated_function (|
              Ty.path "move_binary_format::normalized::Struct",
              "new",
              []
            |),
            [
              M.read (| m |);
              M.call_closure (|
                M.get_associated_function (|
                  Ty.path "move_binary_format::file_format::CompiledModule",
                  "struct_def_at",
                  []
                |),
                [ M.read (| m |); M.read (| M.read (| idx |) |) ]
              |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_from_idx : M.IsAssociatedFunction Self "from_idx" from_idx.
    
    (*
        pub fn type_param_constraints(&self) -> impl ExactSizeIterator<Item = &AbilitySet> {
            self.type_parameters.iter().map(|param| &param.constraints)
        }
    *)
    Definition type_param_constraints (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.call_closure (|
            M.get_trait_method (|
              "core::iter::traits::iterator::Iterator",
              Ty.apply
                (Ty.path "core::slice::iter::Iter")
                []
                [ Ty.path "move_binary_format::file_format::StructTypeParameter" ],
              [],
              "map",
              [
                Ty.apply (Ty.path "&") [] [ Ty.path "move_binary_format::file_format::AbilitySet" ];
                Ty.function
                  [
                    Ty.tuple
                      [
                        Ty.apply
                          (Ty.path "&")
                          []
                          [ Ty.path "move_binary_format::file_format::StructTypeParameter" ]
                      ]
                  ]
                  (Ty.apply
                    (Ty.path "&")
                    []
                    [ Ty.path "move_binary_format::file_format::AbilitySet" ])
              ]
            |),
            [
              M.call_closure (|
                M.get_associated_function (|
                  Ty.apply
                    (Ty.path "slice")
                    []
                    [ Ty.path "move_binary_format::file_format::StructTypeParameter" ],
                  "iter",
                  []
                |),
                [
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::deref::Deref",
                      Ty.apply
                        (Ty.path "alloc::vec::Vec")
                        []
                        [
                          Ty.path "move_binary_format::file_format::StructTypeParameter";
                          Ty.path "alloc::alloc::Global"
                        ],
                      [],
                      "deref",
                      []
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "move_binary_format::normalized::Struct",
                        "type_parameters"
                      |)
                    ]
                  |)
                ]
              |);
              M.closure
                (fun γ =>
                  ltac:(M.monadic
                    match γ with
                    | [ α0 ] =>
                      ltac:(M.monadic
                        (M.match_operator (|
                          M.alloc (| α0 |),
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (let param := M.copy (| γ |) in
                                M.SubPointer.get_struct_record_field (|
                                  M.read (| param |),
                                  "move_binary_format::file_format::StructTypeParameter",
                                  "constraints"
                                |)))
                          ]
                        |)))
                    | _ => M.impossible "wrong number of arguments"
                    end))
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_type_param_constraints :
      M.IsAssociatedFunction Self "type_param_constraints" type_param_constraints.
  End Impl_move_binary_format_normalized_Struct.
  
  Module Impl_move_binary_format_normalized_Function.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Function".
    
    (*
        pub fn new(m: &CompiledModule, def: &FunctionDefinition) -> (Identifier, Self) {
            let fhandle = m.function_handle_at(def.function);
            let name = m.identifier_at(fhandle.name).to_owned();
            let code: Vec<_> = def
                .code
                .as_ref()
                .map(|code| {
                    code.code
                        .iter()
                        .map(|bytecode| Bytecode::new(m, bytecode))
                        .collect()
                })
                .unwrap_or_default();
    
            let f = Function {
                visibility: def.visibility,
                is_entry: def.is_entry,
                type_parameters: fhandle.type_parameters.clone(),
                parameters: m
                    .signature_at(fhandle.parameters)
                    .0
                    .iter()
                    .map(|s| Type::new(m, s))
                    .collect(),
                return_: m
                    .signature_at(fhandle.return_)
                    .0
                    .iter()
                    .map(|s| Type::new(m, s))
                    .collect(),
                code,
            };
            (name, f)
        }
    *)
    Definition new (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ m; def ] =>
        ltac:(M.monadic
          (let m := M.alloc (| m |) in
          let def := M.alloc (| def |) in
          M.read (|
            let~ fhandle :=
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.path "move_binary_format::file_format::CompiledModule",
                    "function_handle_at",
                    []
                  |),
                  [
                    M.read (| m |);
                    M.read (|
                      M.SubPointer.get_struct_record_field (|
                        M.read (| def |),
                        "move_binary_format::file_format::FunctionDefinition",
                        "function"
                      |)
                    |)
                  ]
                |)
              |) in
            let~ name :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (|
                    "alloc::borrow::ToOwned",
                    Ty.path "move_core_types::identifier::IdentStr",
                    [],
                    "to_owned",
                    []
                  |),
                  [
                    M.call_closure (|
                      M.get_associated_function (|
                        Ty.path "move_binary_format::file_format::CompiledModule",
                        "identifier_at",
                        []
                      |),
                      [
                        M.read (| m |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| fhandle |),
                            "move_binary_format::file_format::FunctionHandle",
                            "name"
                          |)
                        |)
                      ]
                    |)
                  ]
                |)
              |) in
            let~ code :=
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.apply
                      (Ty.path "core::option::Option")
                      []
                      [
                        Ty.apply
                          (Ty.path "alloc::vec::Vec")
                          []
                          [
                            Ty.path "move_binary_format::normalized::Bytecode";
                            Ty.path "alloc::alloc::Global"
                          ]
                      ],
                    "unwrap_or_default",
                    []
                  |),
                  [
                    M.call_closure (|
                      M.get_associated_function (|
                        Ty.apply
                          (Ty.path "core::option::Option")
                          []
                          [
                            Ty.apply
                              (Ty.path "&")
                              []
                              [ Ty.path "move_binary_format::file_format::CodeUnit" ]
                          ],
                        "map",
                        [
                          Ty.apply
                            (Ty.path "alloc::vec::Vec")
                            []
                            [
                              Ty.path "move_binary_format::normalized::Bytecode";
                              Ty.path "alloc::alloc::Global"
                            ];
                          Ty.function
                            [
                              Ty.tuple
                                [
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_binary_format::file_format::CodeUnit" ]
                                ]
                            ]
                            (Ty.apply
                              (Ty.path "alloc::vec::Vec")
                              []
                              [
                                Ty.path "move_binary_format::normalized::Bytecode";
                                Ty.path "alloc::alloc::Global"
                              ])
                        ]
                      |),
                      [
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "move_binary_format::file_format::CodeUnit" ],
                            "as_ref",
                            []
                          |),
                          [
                            M.SubPointer.get_struct_record_field (|
                              M.read (| def |),
                              "move_binary_format::file_format::FunctionDefinition",
                              "code"
                            |)
                          ]
                        |);
                        M.closure
                          (fun γ =>
                            ltac:(M.monadic
                              match γ with
                              | [ α0 ] =>
                                ltac:(M.monadic
                                  (M.match_operator (|
                                    M.alloc (| α0 |),
                                    [
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let code := M.copy (| γ |) in
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::iter::traits::iterator::Iterator",
                                              Ty.apply
                                                (Ty.path "core::iter::adapters::map::Map")
                                                []
                                                [
                                                  Ty.apply
                                                    (Ty.path "core::slice::iter::Iter")
                                                    []
                                                    [
                                                      Ty.path
                                                        "move_binary_format::file_format::Bytecode"
                                                    ];
                                                  Ty.function
                                                    [
                                                      Ty.tuple
                                                        [
                                                          Ty.apply
                                                            (Ty.path "&")
                                                            []
                                                            [
                                                              Ty.path
                                                                "move_binary_format::file_format::Bytecode"
                                                            ]
                                                        ]
                                                    ]
                                                    (Ty.path
                                                      "move_binary_format::normalized::Bytecode")
                                                ],
                                              [],
                                              "collect",
                                              [
                                                Ty.apply
                                                  (Ty.path "alloc::vec::Vec")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_binary_format::normalized::Bytecode";
                                                    Ty.path "alloc::alloc::Global"
                                                  ]
                                              ]
                                            |),
                                            [
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::iter::traits::iterator::Iterator",
                                                  Ty.apply
                                                    (Ty.path "core::slice::iter::Iter")
                                                    []
                                                    [
                                                      Ty.path
                                                        "move_binary_format::file_format::Bytecode"
                                                    ],
                                                  [],
                                                  "map",
                                                  [
                                                    Ty.path
                                                      "move_binary_format::normalized::Bytecode";
                                                    Ty.function
                                                      [
                                                        Ty.tuple
                                                          [
                                                            Ty.apply
                                                              (Ty.path "&")
                                                              []
                                                              [
                                                                Ty.path
                                                                  "move_binary_format::file_format::Bytecode"
                                                              ]
                                                          ]
                                                      ]
                                                      (Ty.path
                                                        "move_binary_format::normalized::Bytecode")
                                                  ]
                                                |),
                                                [
                                                  M.call_closure (|
                                                    M.get_associated_function (|
                                                      Ty.apply
                                                        (Ty.path "slice")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_binary_format::file_format::Bytecode"
                                                        ],
                                                      "iter",
                                                      []
                                                    |),
                                                    [
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::ops::deref::Deref",
                                                          Ty.apply
                                                            (Ty.path "alloc::vec::Vec")
                                                            []
                                                            [
                                                              Ty.path
                                                                "move_binary_format::file_format::Bytecode";
                                                              Ty.path "alloc::alloc::Global"
                                                            ],
                                                          [],
                                                          "deref",
                                                          []
                                                        |),
                                                        [
                                                          M.SubPointer.get_struct_record_field (|
                                                            M.read (| code |),
                                                            "move_binary_format::file_format::CodeUnit",
                                                            "code"
                                                          |)
                                                        ]
                                                      |)
                                                    ]
                                                  |);
                                                  M.closure
                                                    (fun γ =>
                                                      ltac:(M.monadic
                                                        match γ with
                                                        | [ α0 ] =>
                                                          ltac:(M.monadic
                                                            (M.match_operator (|
                                                              M.alloc (| α0 |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let bytecode :=
                                                                      M.copy (| γ |) in
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "move_binary_format::normalized::Bytecode",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        M.read (| m |);
                                                                        M.read (| bytecode |)
                                                                      ]
                                                                    |)))
                                                              ]
                                                            |)))
                                                        | _ =>
                                                          M.impossible "wrong number of arguments"
                                                        end))
                                                ]
                                              |)
                                            ]
                                          |)))
                                    ]
                                  |)))
                              | _ => M.impossible "wrong number of arguments"
                              end))
                      ]
                    |)
                  ]
                |)
              |) in
            let~ f :=
              M.alloc (|
                Value.StructRecord
                  "move_binary_format::normalized::Function"
                  [
                    ("visibility",
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| def |),
                          "move_binary_format::file_format::FunctionDefinition",
                          "visibility"
                        |)
                      |));
                    ("is_entry",
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| def |),
                          "move_binary_format::file_format::FunctionDefinition",
                          "is_entry"
                        |)
                      |));
                    ("type_parameters",
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::clone::Clone",
                          Ty.apply
                            (Ty.path "alloc::vec::Vec")
                            []
                            [
                              Ty.path "move_binary_format::file_format::AbilitySet";
                              Ty.path "alloc::alloc::Global"
                            ],
                          [],
                          "clone",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| fhandle |),
                            "move_binary_format::file_format::FunctionHandle",
                            "type_parameters"
                          |)
                        ]
                      |));
                    ("parameters",
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::iter::traits::iterator::Iterator",
                          Ty.apply
                            (Ty.path "core::iter::adapters::map::Map")
                            []
                            [
                              Ty.apply
                                (Ty.path "core::slice::iter::Iter")
                                []
                                [ Ty.path "move_binary_format::file_format::SignatureToken" ];
                              Ty.function
                                [
                                  Ty.tuple
                                    [
                                      Ty.apply
                                        (Ty.path "&")
                                        []
                                        [ Ty.path "move_binary_format::file_format::SignatureToken"
                                        ]
                                    ]
                                ]
                                (Ty.path "move_binary_format::normalized::Type")
                            ],
                          [],
                          "collect",
                          [
                            Ty.apply
                              (Ty.path "alloc::vec::Vec")
                              []
                              [
                                Ty.path "move_binary_format::normalized::Type";
                                Ty.path "alloc::alloc::Global"
                              ]
                          ]
                        |),
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::iter::traits::iterator::Iterator",
                              Ty.apply
                                (Ty.path "core::slice::iter::Iter")
                                []
                                [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                              [],
                              "map",
                              [
                                Ty.path "move_binary_format::normalized::Type";
                                Ty.function
                                  [
                                    Ty.tuple
                                      [
                                        Ty.apply
                                          (Ty.path "&")
                                          []
                                          [
                                            Ty.path
                                              "move_binary_format::file_format::SignatureToken"
                                          ]
                                      ]
                                  ]
                                  (Ty.path "move_binary_format::normalized::Type")
                              ]
                            |),
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.apply
                                    (Ty.path "slice")
                                    []
                                    [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                  "iter",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::ops::deref::Deref",
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::file_format::SignatureToken";
                                          Ty.path "alloc::alloc::Global"
                                        ],
                                      [],
                                      "deref",
                                      []
                                    |),
                                    [
                                      M.SubPointer.get_struct_tuple_field (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path
                                              "move_binary_format::file_format::CompiledModule",
                                            "signature_at",
                                            []
                                          |),
                                          [
                                            M.read (| m |);
                                            M.read (|
                                              M.SubPointer.get_struct_record_field (|
                                                M.read (| fhandle |),
                                                "move_binary_format::file_format::FunctionHandle",
                                                "parameters"
                                              |)
                                            |)
                                          ]
                                        |),
                                        "move_binary_format::file_format::Signature",
                                        0
                                      |)
                                    ]
                                  |)
                                ]
                              |);
                              M.closure
                                (fun γ =>
                                  ltac:(M.monadic
                                    match γ with
                                    | [ α0 ] =>
                                      ltac:(M.monadic
                                        (M.match_operator (|
                                          M.alloc (| α0 |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let s := M.copy (| γ |) in
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "move_binary_format::normalized::Type",
                                                    "new",
                                                    []
                                                  |),
                                                  [ M.read (| m |); M.read (| s |) ]
                                                |)))
                                          ]
                                        |)))
                                    | _ => M.impossible "wrong number of arguments"
                                    end))
                            ]
                          |)
                        ]
                      |));
                    ("return_",
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::iter::traits::iterator::Iterator",
                          Ty.apply
                            (Ty.path "core::iter::adapters::map::Map")
                            []
                            [
                              Ty.apply
                                (Ty.path "core::slice::iter::Iter")
                                []
                                [ Ty.path "move_binary_format::file_format::SignatureToken" ];
                              Ty.function
                                [
                                  Ty.tuple
                                    [
                                      Ty.apply
                                        (Ty.path "&")
                                        []
                                        [ Ty.path "move_binary_format::file_format::SignatureToken"
                                        ]
                                    ]
                                ]
                                (Ty.path "move_binary_format::normalized::Type")
                            ],
                          [],
                          "collect",
                          [
                            Ty.apply
                              (Ty.path "alloc::vec::Vec")
                              []
                              [
                                Ty.path "move_binary_format::normalized::Type";
                                Ty.path "alloc::alloc::Global"
                              ]
                          ]
                        |),
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::iter::traits::iterator::Iterator",
                              Ty.apply
                                (Ty.path "core::slice::iter::Iter")
                                []
                                [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                              [],
                              "map",
                              [
                                Ty.path "move_binary_format::normalized::Type";
                                Ty.function
                                  [
                                    Ty.tuple
                                      [
                                        Ty.apply
                                          (Ty.path "&")
                                          []
                                          [
                                            Ty.path
                                              "move_binary_format::file_format::SignatureToken"
                                          ]
                                      ]
                                  ]
                                  (Ty.path "move_binary_format::normalized::Type")
                              ]
                            |),
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.apply
                                    (Ty.path "slice")
                                    []
                                    [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                  "iter",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::ops::deref::Deref",
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::file_format::SignatureToken";
                                          Ty.path "alloc::alloc::Global"
                                        ],
                                      [],
                                      "deref",
                                      []
                                    |),
                                    [
                                      M.SubPointer.get_struct_tuple_field (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path
                                              "move_binary_format::file_format::CompiledModule",
                                            "signature_at",
                                            []
                                          |),
                                          [
                                            M.read (| m |);
                                            M.read (|
                                              M.SubPointer.get_struct_record_field (|
                                                M.read (| fhandle |),
                                                "move_binary_format::file_format::FunctionHandle",
                                                "return_"
                                              |)
                                            |)
                                          ]
                                        |),
                                        "move_binary_format::file_format::Signature",
                                        0
                                      |)
                                    ]
                                  |)
                                ]
                              |);
                              M.closure
                                (fun γ =>
                                  ltac:(M.monadic
                                    match γ with
                                    | [ α0 ] =>
                                      ltac:(M.monadic
                                        (M.match_operator (|
                                          M.alloc (| α0 |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let s := M.copy (| γ |) in
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "move_binary_format::normalized::Type",
                                                    "new",
                                                    []
                                                  |),
                                                  [ M.read (| m |); M.read (| s |) ]
                                                |)))
                                          ]
                                        |)))
                                    | _ => M.impossible "wrong number of arguments"
                                    end))
                            ]
                          |)
                        ]
                      |));
                    ("code", M.read (| code |))
                  ]
              |) in
            M.alloc (| Value.Tuple [ M.read (| name |); M.read (| f |) ] |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_new : M.IsAssociatedFunction Self "new" new.
    
    (*
        pub fn new_from_name(m: &CompiledModule, func_name: &IdentStr) -> Option<Self> {
            for func_defs in &m.function_defs {
                if m.identifier_at(m.function_handle_at(func_defs.function).name) == func_name {
                    return Some(Self::new(m, func_defs).1);
                }
            }
            None
        }
    *)
    Definition new_from_name (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ m; func_name ] =>
        ltac:(M.monadic
          (let m := M.alloc (| m |) in
          let func_name := M.alloc (| func_name |) in
          M.catch_return (|
            ltac:(M.monadic
              (M.read (|
                let~ _ :=
                  M.use
                    (M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::iter::traits::collect::IntoIterator",
                            Ty.apply
                              (Ty.path "&")
                              []
                              [
                                Ty.apply
                                  (Ty.path "alloc::vec::Vec")
                                  []
                                  [
                                    Ty.path "move_binary_format::file_format::FunctionDefinition";
                                    Ty.path "alloc::alloc::Global"
                                  ]
                              ],
                            [],
                            "into_iter",
                            []
                          |),
                          [
                            M.SubPointer.get_struct_record_field (|
                              M.read (| m |),
                              "move_binary_format::file_format::CompiledModule",
                              "function_defs"
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let iter := M.copy (| γ |) in
                            M.loop (|
                              ltac:(M.monadic
                                (let~ _ :=
                                  M.match_operator (|
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::iter::traits::iterator::Iterator",
                                          Ty.apply
                                            (Ty.path "core::slice::iter::Iter")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::FunctionDefinition"
                                            ],
                                          [],
                                          "next",
                                          []
                                        |),
                                        [ iter ]
                                      |)
                                    |),
                                    [
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let _ :=
                                            M.is_struct_tuple (|
                                              γ,
                                              "core::option::Option::None"
                                            |) in
                                          M.alloc (|
                                            M.never_to_any (| M.read (| M.break (||) |) |)
                                          |)));
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let γ0_0 :=
                                            M.SubPointer.get_struct_tuple_field (|
                                              γ,
                                              "core::option::Option::Some",
                                              0
                                            |) in
                                          let func_defs := M.copy (| γ0_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 "&")
                                                              []
                                                              [
                                                                Ty.path
                                                                  "move_core_types::identifier::IdentStr"
                                                              ],
                                                            [
                                                              Ty.apply
                                                                (Ty.path "&")
                                                                []
                                                                [
                                                                  Ty.path
                                                                    "move_core_types::identifier::IdentStr"
                                                                ]
                                                            ],
                                                            "eq",
                                                            []
                                                          |),
                                                          [
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "move_binary_format::file_format::CompiledModule",
                                                                  "identifier_at",
                                                                  []
                                                                |),
                                                                [
                                                                  M.read (| m |);
                                                                  M.read (|
                                                                    M.SubPointer.get_struct_record_field (|
                                                                      M.call_closure (|
                                                                        M.get_associated_function (|
                                                                          Ty.path
                                                                            "move_binary_format::file_format::CompiledModule",
                                                                          "function_handle_at",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.read (| m |);
                                                                          M.read (|
                                                                            M.SubPointer.get_struct_record_field (|
                                                                              M.read (|
                                                                                func_defs
                                                                              |),
                                                                              "move_binary_format::file_format::FunctionDefinition",
                                                                              "function"
                                                                            |)
                                                                          |)
                                                                        ]
                                                                      |),
                                                                      "move_binary_format::file_format::FunctionHandle",
                                                                      "name"
                                                                    |)
                                                                  |)
                                                                ]
                                                              |)
                                                            |);
                                                            func_name
                                                          ]
                                                        |)
                                                      |)) in
                                                  let _ :=
                                                    M.is_constant_or_break_match (|
                                                      M.read (| γ |),
                                                      Value.Bool true
                                                    |) in
                                                  M.alloc (|
                                                    M.never_to_any (|
                                                      M.read (|
                                                        M.return_ (|
                                                          Value.StructTuple
                                                            "core::option::Option::Some"
                                                            [
                                                              M.read (|
                                                                M.SubPointer.get_tuple_field (|
                                                                  M.alloc (|
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "move_binary_format::normalized::Function",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        M.read (| m |);
                                                                        M.read (| func_defs |)
                                                                      ]
                                                                    |)
                                                                  |),
                                                                  1
                                                                |)
                                                              |)
                                                            ]
                                                        |)
                                                      |)
                                                    |)
                                                  |)));
                                              fun γ =>
                                                ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                            ]
                                          |)))
                                    ]
                                  |) in
                                M.alloc (| Value.Tuple [] |)))
                            |)))
                      ]
                    |)) in
                M.alloc (| Value.StructTuple "core::option::Option::None" [] |)
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_new_from_name :
      M.IsAssociatedFunction Self "new_from_name" new_from_name.
  End Impl_move_binary_format_normalized_Function.
  
  Module Impl_core_convert_From_move_core_types_language_storage_TypeTag_for_move_binary_format_normalized_Type.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Type".
    
    (*
        fn from(ty: TypeTag) -> Type {
            use Type::*;
            match ty {
                TypeTag::Bool => Bool,
                TypeTag::U8 => U8,
                TypeTag::U16 => U16,
                TypeTag::U32 => U32,
                TypeTag::U64 => U64,
                TypeTag::U128 => U128,
                TypeTag::U256 => U256,
                TypeTag::Address => Address,
                TypeTag::Signer => Signer,
                TypeTag::Vector(ty) => Vector(Box::new(Type::from( *ty))),
                TypeTag::Struct(s) => Struct {
                    address: s.address,
                    module: s.module,
                    name: s.name,
                    type_arguments: s.type_params.into_iter().map(|ty| ty.into()).collect(),
                },
            }
        }
    *)
    Definition from (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ ty ] =>
        ltac:(M.monadic
          (let ty := M.alloc (| ty |) in
          M.read (|
            M.match_operator (|
              ty,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_core_types::language_storage::TypeTag::Bool"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::Bool" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let _ :=
                      M.is_struct_tuple (| γ, "move_core_types::language_storage::TypeTag::U8" |) in
                    M.alloc (| Value.StructTuple "move_binary_format::normalized::Type::U8" [] |)));
                fun γ =>
                  ltac:(M.monadic
                    (let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_core_types::language_storage::TypeTag::U16"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::U16" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_core_types::language_storage::TypeTag::U32"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::U32" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_core_types::language_storage::TypeTag::U64"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::U64" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_core_types::language_storage::TypeTag::U128"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::U128" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_core_types::language_storage::TypeTag::U256"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::U256" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_core_types::language_storage::TypeTag::Address"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::Address" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_core_types::language_storage::TypeTag::Signer"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Type::Signer" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::language_storage::TypeTag::Vector",
                        0
                      |) in
                    let ty := M.copy (| γ0_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Type::Vector"
                        [
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.apply
                                (Ty.path "alloc::boxed::Box")
                                []
                                [
                                  Ty.path "move_binary_format::normalized::Type";
                                  Ty.path "alloc::alloc::Global"
                                ],
                              "new",
                              []
                            |),
                            [
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::convert::From",
                                  Ty.path "move_binary_format::normalized::Type",
                                  [ Ty.path "move_core_types::language_storage::TypeTag" ],
                                  "from",
                                  []
                                |),
                                [ M.read (| M.read (| ty |) |) ]
                              |)
                            ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::language_storage::TypeTag::Struct",
                        0
                      |) in
                    let s := M.copy (| γ0_0 |) in
                    M.alloc (|
                      Value.StructRecord
                        "move_binary_format::normalized::Type::Struct"
                        [
                          ("address",
                            M.read (|
                              M.SubPointer.get_struct_record_field (|
                                M.read (| s |),
                                "move_core_types::language_storage::StructTag",
                                "address"
                              |)
                            |));
                          ("module",
                            M.read (|
                              M.SubPointer.get_struct_record_field (|
                                M.read (| s |),
                                "move_core_types::language_storage::StructTag",
                                "module"
                              |)
                            |));
                          ("name",
                            M.read (|
                              M.SubPointer.get_struct_record_field (|
                                M.read (| s |),
                                "move_core_types::language_storage::StructTag",
                                "name"
                              |)
                            |));
                          ("type_arguments",
                            M.call_closure (|
                              M.get_trait_method (|
                                "core::iter::traits::iterator::Iterator",
                                Ty.apply
                                  (Ty.path "core::iter::adapters::map::Map")
                                  []
                                  [
                                    Ty.apply
                                      (Ty.path "alloc::vec::into_iter::IntoIter")
                                      []
                                      [
                                        Ty.path "move_core_types::language_storage::TypeTag";
                                        Ty.path "alloc::alloc::Global"
                                      ];
                                    Ty.function
                                      [
                                        Ty.tuple
                                          [ Ty.path "move_core_types::language_storage::TypeTag" ]
                                      ]
                                      (Ty.path "move_binary_format::normalized::Type")
                                  ],
                                [],
                                "collect",
                                [
                                  Ty.apply
                                    (Ty.path "alloc::vec::Vec")
                                    []
                                    [
                                      Ty.path "move_binary_format::normalized::Type";
                                      Ty.path "alloc::alloc::Global"
                                    ]
                                ]
                              |),
                              [
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::iter::traits::iterator::Iterator",
                                    Ty.apply
                                      (Ty.path "alloc::vec::into_iter::IntoIter")
                                      []
                                      [
                                        Ty.path "move_core_types::language_storage::TypeTag";
                                        Ty.path "alloc::alloc::Global"
                                      ],
                                    [],
                                    "map",
                                    [
                                      Ty.path "move_binary_format::normalized::Type";
                                      Ty.function
                                        [
                                          Ty.tuple
                                            [ Ty.path "move_core_types::language_storage::TypeTag" ]
                                        ]
                                        (Ty.path "move_binary_format::normalized::Type")
                                    ]
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_trait_method (|
                                        "core::iter::traits::collect::IntoIterator",
                                        Ty.apply
                                          (Ty.path "alloc::vec::Vec")
                                          []
                                          [
                                            Ty.path "move_core_types::language_storage::TypeTag";
                                            Ty.path "alloc::alloc::Global"
                                          ],
                                        [],
                                        "into_iter",
                                        []
                                      |),
                                      [
                                        M.read (|
                                          M.SubPointer.get_struct_record_field (|
                                            M.read (| s |),
                                            "move_core_types::language_storage::StructTag",
                                            "type_params"
                                          |)
                                        |)
                                      ]
                                    |);
                                    M.closure
                                      (fun γ =>
                                        ltac:(M.monadic
                                          match γ with
                                          | [ α0 ] =>
                                            ltac:(M.monadic
                                              (M.match_operator (|
                                                M.alloc (| α0 |),
                                                [
                                                  fun γ =>
                                                    ltac:(M.monadic
                                                      (let ty := M.copy (| γ |) in
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::convert::Into",
                                                          Ty.path
                                                            "move_core_types::language_storage::TypeTag",
                                                          [
                                                            Ty.path
                                                              "move_binary_format::normalized::Type"
                                                          ],
                                                          "into",
                                                          []
                                                        |),
                                                        [ M.read (| ty |) ]
                                                      |)))
                                                ]
                                              |)))
                                          | _ => M.impossible "wrong number of arguments"
                                          end))
                                  ]
                                |)
                              ]
                            |))
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::convert::From"
        Self
        (* Trait polymorphic types *)
        [ (* T *) Ty.path "move_core_types::language_storage::TypeTag" ]
        (* Instance *) [ ("from", InstanceField.Method from) ].
  End Impl_core_convert_From_move_core_types_language_storage_TypeTag_for_move_binary_format_normalized_Type.
  
  Module Impl_move_binary_format_normalized_FieldRef.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::FieldRef".
    
    (*
        pub fn new(m: &CompiledModule, field_handle: &FieldHandle) -> Self {
            Self {
                struct_name: m.struct_name(field_handle.owner).to_owned(),
                field_index: field_handle.field,
            }
        }
    *)
    Definition new (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ m; field_handle ] =>
        ltac:(M.monadic
          (let m := M.alloc (| m |) in
          let field_handle := M.alloc (| field_handle |) in
          Value.StructRecord
            "move_binary_format::normalized::FieldRef"
            [
              ("struct_name",
                M.call_closure (|
                  M.get_trait_method (|
                    "alloc::borrow::ToOwned",
                    Ty.path "move_core_types::identifier::IdentStr",
                    [],
                    "to_owned",
                    []
                  |),
                  [
                    M.call_closure (|
                      M.get_associated_function (|
                        Ty.path "move_binary_format::file_format::CompiledModule",
                        "struct_name",
                        []
                      |),
                      [
                        M.read (| m |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| field_handle |),
                            "move_binary_format::file_format::FieldHandle",
                            "owner"
                          |)
                        |)
                      ]
                    |)
                  ]
                |));
              ("field_index",
                M.read (|
                  M.SubPointer.get_struct_record_field (|
                    M.read (| field_handle |),
                    "move_binary_format::file_format::FieldHandle",
                    "field"
                  |)
                |))
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_new : M.IsAssociatedFunction Self "new" new.
    
    (*
        pub fn from_idx(m: &CompiledModule, field_handle_idx: &FieldHandleIndex) -> Self {
            Self::new(m, m.field_handle_at( *field_handle_idx))
        }
    *)
    Definition from_idx (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ m; field_handle_idx ] =>
        ltac:(M.monadic
          (let m := M.alloc (| m |) in
          let field_handle_idx := M.alloc (| field_handle_idx |) in
          M.call_closure (|
            M.get_associated_function (|
              Ty.path "move_binary_format::normalized::FieldRef",
              "new",
              []
            |),
            [
              M.read (| m |);
              M.call_closure (|
                M.get_associated_function (|
                  Ty.path "move_binary_format::file_format::CompiledModule",
                  "field_handle_at",
                  []
                |),
                [ M.read (| m |); M.read (| M.read (| field_handle_idx |) |) ]
              |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_from_idx : M.IsAssociatedFunction Self "from_idx" from_idx.
  End Impl_move_binary_format_normalized_FieldRef.
  
  Module Impl_move_binary_format_normalized_FunctionRef.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::FunctionRef".
    
    (*
        pub fn new(m: &CompiledModule, function_handle: &FunctionHandle) -> Self {
            Self {
                module_id: m.module_id_for_handle(m.module_handle_at(function_handle.module)),
                function_ident: m.identifier_at(function_handle.name).to_owned(),
            }
        }
    *)
    Definition new (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ m; function_handle ] =>
        ltac:(M.monadic
          (let m := M.alloc (| m |) in
          let function_handle := M.alloc (| function_handle |) in
          Value.StructRecord
            "move_binary_format::normalized::FunctionRef"
            [
              ("module_id",
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.path "move_binary_format::file_format::CompiledModule",
                    "module_id_for_handle",
                    []
                  |),
                  [
                    M.read (| m |);
                    M.call_closure (|
                      M.get_associated_function (|
                        Ty.path "move_binary_format::file_format::CompiledModule",
                        "module_handle_at",
                        []
                      |),
                      [
                        M.read (| m |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| function_handle |),
                            "move_binary_format::file_format::FunctionHandle",
                            "module"
                          |)
                        |)
                      ]
                    |)
                  ]
                |));
              ("function_ident",
                M.call_closure (|
                  M.get_trait_method (|
                    "alloc::borrow::ToOwned",
                    Ty.path "move_core_types::identifier::IdentStr",
                    [],
                    "to_owned",
                    []
                  |),
                  [
                    M.call_closure (|
                      M.get_associated_function (|
                        Ty.path "move_binary_format::file_format::CompiledModule",
                        "identifier_at",
                        []
                      |),
                      [
                        M.read (| m |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| function_handle |),
                            "move_binary_format::file_format::FunctionHandle",
                            "name"
                          |)
                        |)
                      ]
                    |)
                  ]
                |))
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_new : M.IsAssociatedFunction Self "new" new.
    
    (*
        pub fn from_idx(m: &CompiledModule, function_handle_idx: &FunctionHandleIndex) -> Self {
            Self::new(m, m.function_handle_at( *function_handle_idx))
        }
    *)
    Definition from_idx (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ m; function_handle_idx ] =>
        ltac:(M.monadic
          (let m := M.alloc (| m |) in
          let function_handle_idx := M.alloc (| function_handle_idx |) in
          M.call_closure (|
            M.get_associated_function (|
              Ty.path "move_binary_format::normalized::FunctionRef",
              "new",
              []
            |),
            [
              M.read (| m |);
              M.call_closure (|
                M.get_associated_function (|
                  Ty.path "move_binary_format::file_format::CompiledModule",
                  "function_handle_at",
                  []
                |),
                [ M.read (| m |); M.read (| M.read (| function_handle_idx |) |) ]
              |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_from_idx : M.IsAssociatedFunction Self "from_idx" from_idx.
  End Impl_move_binary_format_normalized_FunctionRef.
  
  Module Impl_move_binary_format_normalized_Bytecode.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Bytecode".
    
    (*
        pub fn new(m: &CompiledModule, bytecode: &FBytecode) -> Self {
            use Bytecode as B;
            use FBytecode as FB;
            match bytecode {
                FB::Pop => B::Pop,
                FB::Ret => B::Ret,
                FB::CastU8 => B::CastU8,
                FB::CastU64 => B::CastU64,
                FB::CastU128 => B::CastU128,
                FB::LdTrue => B::LdTrue,
                FB::LdFalse => B::LdFalse,
                FB::ReadRef => B::ReadRef,
                FB::WriteRef => B::WriteRef,
                FB::FreezeRef => B::FreezeRef,
                FB::Add => B::Add,
                FB::Sub => B::Sub,
                FB::Mul => B::Mul,
                FB::Mod => B::Mod,
                FB::Div => B::Div,
                FB::BitOr => B::BitOr,
                FB::BitAnd => B::BitAnd,
                FB::Xor => B::Xor,
                FB::Or => B::Or,
                FB::And => B::And,
                FB::Not => B::Not,
                FB::Eq => B::Eq,
                FB::Neq => B::Neq,
                FB::Lt => B::Lt,
                FB::Gt => B::Gt,
                FB::Le => B::Le,
                FB::Ge => B::Ge,
                FB::Abort => B::Abort,
                FB::Nop => B::Nop,
                FB::Shl => B::Shl,
                FB::Shr => B::Shr,
                FB::CastU16 => B::CastU16,
                FB::CastU32 => B::CastU32,
                FB::CastU256 => B::CastU256,
                FB::BrTrue(x) => B::BrTrue( *x),
                FB::BrFalse(x) => B::BrFalse( *x),
                FB::Branch(x) => B::Branch( *x),
                FB::LdU8(x) => B::LdU8( *x),
                FB::LdU64(x) => B::LdU64( *x),
                FB::LdU128(x) => B::LdU128( **x),
                FB::CopyLoc(x) => B::CopyLoc( *x),
                FB::MoveLoc(x) => B::MoveLoc( *x),
                FB::StLoc(x) => B::StLoc( *x),
                FB::LdU16(x) => B::LdU16( *x),
                FB::LdU32(x) => B::LdU32( *x),
                FB::LdU256(x) => B::LdU256( **x),
                FB::LdConst(const_idx) => B::LdConst(Constant::new(m, m.constant_at( *const_idx))),
                FB::Call(fh_idx) => B::Call(FunctionRef::from_idx(m, fh_idx)),
                FB::CallGeneric(fhi_idx) => {
                    let FunctionInstantiation {
                        handle,
                        type_parameters,
                    } = m.function_instantiation_at( *fhi_idx);
                    let type_params = m.signature_at( *type_parameters);
                    B::CallGeneric((
                        FunctionRef::from_idx(m, handle),
                        type_params.0.iter().map(|tok| Type::new(m, tok)).collect(),
                    ))
                }
                FB::Pack(s_idx) => B::Pack(m.struct_name( *s_idx).to_owned()),
                FB::PackGeneric(s_idx) => B::PackGeneric(struct_instantiation(m, s_idx)),
                FB::Unpack(s_idx) => B::Unpack(m.struct_name( *s_idx).to_owned()),
                FB::UnpackGeneric(si_idx) => B::UnpackGeneric(struct_instantiation(m, si_idx)),
                FB::MutBorrowLoc(x) => B::MutBorrowLoc( *x),
                FB::ImmBorrowLoc(x) => B::ImmBorrowLoc( *x),
                FB::MutBorrowField(fh_ixd) => B::MutBorrowField(FieldRef::from_idx(m, fh_ixd)),
                FB::MutBorrowFieldGeneric(fhi_idx) => {
                    B::MutBorrowFieldGeneric(field_instantiation(m, fhi_idx))
                }
                FB::ImmBorrowField(fh_idx) => B::ImmBorrowField(FieldRef::from_idx(m, fh_idx)),
                FB::ImmBorrowFieldGeneric(fhi_idx) => {
                    B::ImmBorrowFieldGeneric(field_instantiation(m, fhi_idx))
                }
                FB::MutBorrowGlobalDeprecated(s_idx) => {
                    B::MutBorrowGlobalDeprecated(m.struct_name( *s_idx).to_owned())
                }
                FB::MutBorrowGlobalGenericDeprecated(si_idx) => {
                    B::MutBorrowGlobalGenericDeprecated(struct_instantiation(m, si_idx))
                }
                FB::ImmBorrowGlobalDeprecated(s_idx) => {
                    B::ImmBorrowGlobalDeprecated(m.struct_name( *s_idx).to_owned())
                }
                FB::ImmBorrowGlobalGenericDeprecated(si_idx) => {
                    B::ImmBorrowGlobalGenericDeprecated(struct_instantiation(m, si_idx))
                }
                FB::ExistsDeprecated(s_idx) => B::ExistsDeprecated(m.struct_name( *s_idx).to_owned()),
                FB::ExistsGenericDeprecated(si_idx) => {
                    B::ExistsGenericDeprecated(struct_instantiation(m, si_idx))
                }
                FB::MoveFromDeprecated(s_idx) => {
                    B::MoveFromDeprecated(m.struct_name( *s_idx).to_owned())
                }
                FB::MoveFromGenericDeprecated(si_idx) => {
                    B::MoveFromGenericDeprecated(struct_instantiation(m, si_idx))
                }
                FB::MoveToDeprecated(s_idx) => B::MoveToDeprecated(m.struct_name( *s_idx).to_owned()),
                FB::MoveToGenericDeprecated(si_idx) => {
                    B::MoveToGenericDeprecated(struct_instantiation(m, si_idx))
                }
                FB::VecPack(sig_idx, len) => B::VecPack(signature_to_single_type(m, sig_idx), *len),
                FB::VecLen(sig_idx) => B::VecLen(signature_to_single_type(m, sig_idx)),
                FB::VecImmBorrow(sig_idx) => B::VecImmBorrow(signature_to_single_type(m, sig_idx)),
                FB::VecMutBorrow(sig_idx) => B::VecMutBorrow(signature_to_single_type(m, sig_idx)),
                FB::VecPushBack(sig_idx) => B::VecPushBack(signature_to_single_type(m, sig_idx)),
                FB::VecPopBack(sig_idx) => B::VecPopBack(signature_to_single_type(m, sig_idx)),
                FB::VecUnpack(sig_idx, len) => B::VecUnpack(signature_to_single_type(m, sig_idx), *len),
                FB::VecSwap(sig_idx) => B::VecSwap(signature_to_single_type(m, sig_idx)),
            }
        }
    *)
    Definition new (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ m; bytecode ] =>
        ltac:(M.monadic
          (let m := M.alloc (| m |) in
          let bytecode := M.alloc (| bytecode |) in
          M.read (|
            M.match_operator (|
              bytecode,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::file_format::Bytecode::Pop" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Pop" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::file_format::Bytecode::Ret" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Ret" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::Bytecode::CastU8"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::CastU8" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::Bytecode::CastU64"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::CastU64" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::Bytecode::CastU128"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::CastU128" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::Bytecode::LdTrue"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::LdTrue" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::Bytecode::LdFalse"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::LdFalse" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::Bytecode::ReadRef"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::ReadRef" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::Bytecode::WriteRef"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::WriteRef" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::Bytecode::FreezeRef"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::FreezeRef" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::file_format::Bytecode::Add" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Add" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::file_format::Bytecode::Sub" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Sub" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::file_format::Bytecode::Mul" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Mul" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::file_format::Bytecode::Mod" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Mod" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::file_format::Bytecode::Div" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Div" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::Bytecode::BitOr"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::BitOr" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::Bytecode::BitAnd"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::BitAnd" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::file_format::Bytecode::Xor" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Xor" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::file_format::Bytecode::Or" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Or" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::file_format::Bytecode::And" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::And" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::file_format::Bytecode::Not" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Not" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::file_format::Bytecode::Eq" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Eq" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::file_format::Bytecode::Neq" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Neq" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::file_format::Bytecode::Lt" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Lt" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::file_format::Bytecode::Gt" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Gt" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::file_format::Bytecode::Le" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Le" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::file_format::Bytecode::Ge" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Ge" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::Bytecode::Abort"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Abort" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::file_format::Bytecode::Nop" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Nop" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::file_format::Bytecode::Shl" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Shl" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (| γ, "move_binary_format::file_format::Bytecode::Shr" |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::Shr" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::Bytecode::CastU16"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::CastU16" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::Bytecode::CastU32"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::CastU32" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let _ :=
                      M.is_struct_tuple (|
                        γ,
                        "move_binary_format::file_format::Bytecode::CastU256"
                      |) in
                    M.alloc (|
                      Value.StructTuple "move_binary_format::normalized::Bytecode::CastU256" []
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::BrTrue",
                        0
                      |) in
                    let x := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::BrTrue"
                        [ M.read (| M.read (| x |) |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::BrFalse",
                        0
                      |) in
                    let x := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::BrFalse"
                        [ M.read (| M.read (| x |) |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::Branch",
                        0
                      |) in
                    let x := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::Branch"
                        [ M.read (| M.read (| x |) |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::LdU8",
                        0
                      |) in
                    let x := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::LdU8"
                        [ M.read (| M.read (| x |) |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::LdU64",
                        0
                      |) in
                    let x := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::LdU64"
                        [ M.read (| M.read (| x |) |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::LdU128",
                        0
                      |) in
                    let x := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::LdU128"
                        [ M.read (| M.read (| M.read (| x |) |) |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::CopyLoc",
                        0
                      |) in
                    let x := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::CopyLoc"
                        [ M.read (| M.read (| x |) |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::MoveLoc",
                        0
                      |) in
                    let x := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::MoveLoc"
                        [ M.read (| M.read (| x |) |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::StLoc",
                        0
                      |) in
                    let x := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::StLoc"
                        [ M.read (| M.read (| x |) |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::LdU16",
                        0
                      |) in
                    let x := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::LdU16"
                        [ M.read (| M.read (| x |) |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::LdU32",
                        0
                      |) in
                    let x := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::LdU32"
                        [ M.read (| M.read (| x |) |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::LdU256",
                        0
                      |) in
                    let x := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::LdU256"
                        [ M.read (| M.read (| M.read (| x |) |) |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::LdConst",
                        0
                      |) in
                    let const_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::LdConst"
                        [
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "move_binary_format::normalized::Constant",
                              "new",
                              []
                            |),
                            [
                              M.read (| m |);
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::file_format::CompiledModule",
                                  "constant_at",
                                  []
                                |),
                                [ M.read (| m |); M.read (| M.read (| const_idx |) |) ]
                              |)
                            ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::Call",
                        0
                      |) in
                    let fh_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::Call"
                        [
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "move_binary_format::normalized::FunctionRef",
                              "from_idx",
                              []
                            |),
                            [ M.read (| m |); M.read (| fh_idx |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::CallGeneric",
                        0
                      |) in
                    let fhi_idx := M.alloc (| γ1_0 |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "move_binary_format::file_format::CompiledModule",
                            "function_instantiation_at",
                            []
                          |),
                          [ M.read (| m |); M.read (| M.read (| fhi_idx |) |) ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ := M.read (| γ |) in
                            let γ1_0 :=
                              M.SubPointer.get_struct_record_field (|
                                γ,
                                "move_binary_format::file_format::FunctionInstantiation",
                                "handle"
                              |) in
                            let γ1_1 :=
                              M.SubPointer.get_struct_record_field (|
                                γ,
                                "move_binary_format::file_format::FunctionInstantiation",
                                "type_parameters"
                              |) in
                            let handle := M.alloc (| γ1_0 |) in
                            let type_parameters := M.alloc (| γ1_1 |) in
                            let~ type_params :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path "move_binary_format::file_format::CompiledModule",
                                    "signature_at",
                                    []
                                  |),
                                  [ M.read (| m |); M.read (| M.read (| type_parameters |) |) ]
                                |)
                              |) in
                            M.alloc (|
                              Value.StructTuple
                                "move_binary_format::normalized::Bytecode::CallGeneric"
                                [
                                  Value.Tuple
                                    [
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.path "move_binary_format::normalized::FunctionRef",
                                          "from_idx",
                                          []
                                        |),
                                        [ M.read (| m |); M.read (| handle |) ]
                                      |);
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::iter::traits::iterator::Iterator",
                                          Ty.apply
                                            (Ty.path "core::iter::adapters::map::Map")
                                            []
                                            [
                                              Ty.apply
                                                (Ty.path "core::slice::iter::Iter")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::SignatureToken"
                                                ];
                                              Ty.function
                                                [
                                                  Ty.tuple
                                                    [
                                                      Ty.apply
                                                        (Ty.path "&")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_binary_format::file_format::SignatureToken"
                                                        ]
                                                    ]
                                                ]
                                                (Ty.path "move_binary_format::normalized::Type")
                                            ],
                                          [],
                                          "collect",
                                          [
                                            Ty.apply
                                              (Ty.path "alloc::vec::Vec")
                                              []
                                              [
                                                Ty.path "move_binary_format::normalized::Type";
                                                Ty.path "alloc::alloc::Global"
                                              ]
                                          ]
                                        |),
                                        [
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::iter::traits::iterator::Iterator",
                                              Ty.apply
                                                (Ty.path "core::slice::iter::Iter")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::SignatureToken"
                                                ],
                                              [],
                                              "map",
                                              [
                                                Ty.path "move_binary_format::normalized::Type";
                                                Ty.function
                                                  [
                                                    Ty.tuple
                                                      [
                                                        Ty.apply
                                                          (Ty.path "&")
                                                          []
                                                          [
                                                            Ty.path
                                                              "move_binary_format::file_format::SignatureToken"
                                                          ]
                                                      ]
                                                  ]
                                                  (Ty.path "move_binary_format::normalized::Type")
                                              ]
                                            |),
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.apply
                                                    (Ty.path "slice")
                                                    []
                                                    [
                                                      Ty.path
                                                        "move_binary_format::file_format::SignatureToken"
                                                    ],
                                                  "iter",
                                                  []
                                                |),
                                                [
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::ops::deref::Deref",
                                                      Ty.apply
                                                        (Ty.path "alloc::vec::Vec")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_binary_format::file_format::SignatureToken";
                                                          Ty.path "alloc::alloc::Global"
                                                        ],
                                                      [],
                                                      "deref",
                                                      []
                                                    |),
                                                    [
                                                      M.SubPointer.get_struct_tuple_field (|
                                                        M.read (| type_params |),
                                                        "move_binary_format::file_format::Signature",
                                                        0
                                                      |)
                                                    ]
                                                  |)
                                                ]
                                              |);
                                              M.closure
                                                (fun γ =>
                                                  ltac:(M.monadic
                                                    match γ with
                                                    | [ α0 ] =>
                                                      ltac:(M.monadic
                                                        (M.match_operator (|
                                                          M.alloc (| α0 |),
                                                          [
                                                            fun γ =>
                                                              ltac:(M.monadic
                                                                (let tok := M.copy (| γ |) in
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.path
                                                                      "move_binary_format::normalized::Type",
                                                                    "new",
                                                                    []
                                                                  |),
                                                                  [ M.read (| m |); M.read (| tok |)
                                                                  ]
                                                                |)))
                                                          ]
                                                        |)))
                                                    | _ => M.impossible "wrong number of arguments"
                                                    end))
                                            ]
                                          |)
                                        ]
                                      |)
                                    ]
                                ]
                            |)))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::Pack",
                        0
                      |) in
                    let s_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::Pack"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "alloc::borrow::ToOwned",
                              Ty.path "move_core_types::identifier::IdentStr",
                              [],
                              "to_owned",
                              []
                            |),
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::file_format::CompiledModule",
                                  "struct_name",
                                  []
                                |),
                                [ M.read (| m |); M.read (| M.read (| s_idx |) |) ]
                              |)
                            ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::PackGeneric",
                        0
                      |) in
                    let s_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::PackGeneric"
                        [
                          M.call_closure (|
                            M.get_function (|
                              "move_binary_format::normalized::struct_instantiation",
                              []
                            |),
                            [ M.read (| m |); M.read (| s_idx |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::Unpack",
                        0
                      |) in
                    let s_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::Unpack"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "alloc::borrow::ToOwned",
                              Ty.path "move_core_types::identifier::IdentStr",
                              [],
                              "to_owned",
                              []
                            |),
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::file_format::CompiledModule",
                                  "struct_name",
                                  []
                                |),
                                [ M.read (| m |); M.read (| M.read (| s_idx |) |) ]
                              |)
                            ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::UnpackGeneric",
                        0
                      |) in
                    let si_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::UnpackGeneric"
                        [
                          M.call_closure (|
                            M.get_function (|
                              "move_binary_format::normalized::struct_instantiation",
                              []
                            |),
                            [ M.read (| m |); M.read (| si_idx |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::MutBorrowLoc",
                        0
                      |) in
                    let x := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::MutBorrowLoc"
                        [ M.read (| M.read (| x |) |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::ImmBorrowLoc",
                        0
                      |) in
                    let x := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::ImmBorrowLoc"
                        [ M.read (| M.read (| x |) |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::MutBorrowField",
                        0
                      |) in
                    let fh_ixd := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::MutBorrowField"
                        [
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "move_binary_format::normalized::FieldRef",
                              "from_idx",
                              []
                            |),
                            [ M.read (| m |); M.read (| fh_ixd |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::MutBorrowFieldGeneric",
                        0
                      |) in
                    let fhi_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::MutBorrowFieldGeneric"
                        [
                          M.call_closure (|
                            M.get_function (|
                              "move_binary_format::normalized::field_instantiation",
                              []
                            |),
                            [ M.read (| m |); M.read (| fhi_idx |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::ImmBorrowField",
                        0
                      |) in
                    let fh_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::ImmBorrowField"
                        [
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "move_binary_format::normalized::FieldRef",
                              "from_idx",
                              []
                            |),
                            [ M.read (| m |); M.read (| fh_idx |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::ImmBorrowFieldGeneric",
                        0
                      |) in
                    let fhi_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::ImmBorrowFieldGeneric"
                        [
                          M.call_closure (|
                            M.get_function (|
                              "move_binary_format::normalized::field_instantiation",
                              []
                            |),
                            [ M.read (| m |); M.read (| fhi_idx |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::MutBorrowGlobalDeprecated",
                        0
                      |) in
                    let s_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::MutBorrowGlobalDeprecated"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "alloc::borrow::ToOwned",
                              Ty.path "move_core_types::identifier::IdentStr",
                              [],
                              "to_owned",
                              []
                            |),
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::file_format::CompiledModule",
                                  "struct_name",
                                  []
                                |),
                                [ M.read (| m |); M.read (| M.read (| s_idx |) |) ]
                              |)
                            ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::MutBorrowGlobalGenericDeprecated",
                        0
                      |) in
                    let si_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::MutBorrowGlobalGenericDeprecated"
                        [
                          M.call_closure (|
                            M.get_function (|
                              "move_binary_format::normalized::struct_instantiation",
                              []
                            |),
                            [ M.read (| m |); M.read (| si_idx |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::ImmBorrowGlobalDeprecated",
                        0
                      |) in
                    let s_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::ImmBorrowGlobalDeprecated"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "alloc::borrow::ToOwned",
                              Ty.path "move_core_types::identifier::IdentStr",
                              [],
                              "to_owned",
                              []
                            |),
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::file_format::CompiledModule",
                                  "struct_name",
                                  []
                                |),
                                [ M.read (| m |); M.read (| M.read (| s_idx |) |) ]
                              |)
                            ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::ImmBorrowGlobalGenericDeprecated",
                        0
                      |) in
                    let si_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::ImmBorrowGlobalGenericDeprecated"
                        [
                          M.call_closure (|
                            M.get_function (|
                              "move_binary_format::normalized::struct_instantiation",
                              []
                            |),
                            [ M.read (| m |); M.read (| si_idx |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::ExistsDeprecated",
                        0
                      |) in
                    let s_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::ExistsDeprecated"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "alloc::borrow::ToOwned",
                              Ty.path "move_core_types::identifier::IdentStr",
                              [],
                              "to_owned",
                              []
                            |),
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::file_format::CompiledModule",
                                  "struct_name",
                                  []
                                |),
                                [ M.read (| m |); M.read (| M.read (| s_idx |) |) ]
                              |)
                            ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::ExistsGenericDeprecated",
                        0
                      |) in
                    let si_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::ExistsGenericDeprecated"
                        [
                          M.call_closure (|
                            M.get_function (|
                              "move_binary_format::normalized::struct_instantiation",
                              []
                            |),
                            [ M.read (| m |); M.read (| si_idx |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::MoveFromDeprecated",
                        0
                      |) in
                    let s_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::MoveFromDeprecated"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "alloc::borrow::ToOwned",
                              Ty.path "move_core_types::identifier::IdentStr",
                              [],
                              "to_owned",
                              []
                            |),
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::file_format::CompiledModule",
                                  "struct_name",
                                  []
                                |),
                                [ M.read (| m |); M.read (| M.read (| s_idx |) |) ]
                              |)
                            ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::MoveFromGenericDeprecated",
                        0
                      |) in
                    let si_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::MoveFromGenericDeprecated"
                        [
                          M.call_closure (|
                            M.get_function (|
                              "move_binary_format::normalized::struct_instantiation",
                              []
                            |),
                            [ M.read (| m |); M.read (| si_idx |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::MoveToDeprecated",
                        0
                      |) in
                    let s_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::MoveToDeprecated"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "alloc::borrow::ToOwned",
                              Ty.path "move_core_types::identifier::IdentStr",
                              [],
                              "to_owned",
                              []
                            |),
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::file_format::CompiledModule",
                                  "struct_name",
                                  []
                                |),
                                [ M.read (| m |); M.read (| M.read (| s_idx |) |) ]
                              |)
                            ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::MoveToGenericDeprecated",
                        0
                      |) in
                    let si_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::MoveToGenericDeprecated"
                        [
                          M.call_closure (|
                            M.get_function (|
                              "move_binary_format::normalized::struct_instantiation",
                              []
                            |),
                            [ M.read (| m |); M.read (| si_idx |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::VecPack",
                        0
                      |) in
                    let γ1_1 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::VecPack",
                        1
                      |) in
                    let sig_idx := M.alloc (| γ1_0 |) in
                    let len := M.alloc (| γ1_1 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::VecPack"
                        [
                          M.call_closure (|
                            M.get_function (|
                              "move_binary_format::normalized::signature_to_single_type",
                              []
                            |),
                            [ M.read (| m |); M.read (| sig_idx |) ]
                          |);
                          M.read (| M.read (| len |) |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::VecLen",
                        0
                      |) in
                    let sig_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::VecLen"
                        [
                          M.call_closure (|
                            M.get_function (|
                              "move_binary_format::normalized::signature_to_single_type",
                              []
                            |),
                            [ M.read (| m |); M.read (| sig_idx |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::VecImmBorrow",
                        0
                      |) in
                    let sig_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::VecImmBorrow"
                        [
                          M.call_closure (|
                            M.get_function (|
                              "move_binary_format::normalized::signature_to_single_type",
                              []
                            |),
                            [ M.read (| m |); M.read (| sig_idx |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::VecMutBorrow",
                        0
                      |) in
                    let sig_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::VecMutBorrow"
                        [
                          M.call_closure (|
                            M.get_function (|
                              "move_binary_format::normalized::signature_to_single_type",
                              []
                            |),
                            [ M.read (| m |); M.read (| sig_idx |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::VecPushBack",
                        0
                      |) in
                    let sig_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::VecPushBack"
                        [
                          M.call_closure (|
                            M.get_function (|
                              "move_binary_format::normalized::signature_to_single_type",
                              []
                            |),
                            [ M.read (| m |); M.read (| sig_idx |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::VecPopBack",
                        0
                      |) in
                    let sig_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::VecPopBack"
                        [
                          M.call_closure (|
                            M.get_function (|
                              "move_binary_format::normalized::signature_to_single_type",
                              []
                            |),
                            [ M.read (| m |); M.read (| sig_idx |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::VecUnpack",
                        0
                      |) in
                    let γ1_1 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::VecUnpack",
                        1
                      |) in
                    let sig_idx := M.alloc (| γ1_0 |) in
                    let len := M.alloc (| γ1_1 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::VecUnpack"
                        [
                          M.call_closure (|
                            M.get_function (|
                              "move_binary_format::normalized::signature_to_single_type",
                              []
                            |),
                            [ M.read (| m |); M.read (| sig_idx |) ]
                          |);
                          M.read (| M.read (| len |) |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_binary_format::file_format::Bytecode::VecSwap",
                        0
                      |) in
                    let sig_idx := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_binary_format::normalized::Bytecode::VecSwap"
                        [
                          M.call_closure (|
                            M.get_function (|
                              "move_binary_format::normalized::signature_to_single_type",
                              []
                            |),
                            [ M.read (| m |); M.read (| sig_idx |) ]
                          |)
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_new : M.IsAssociatedFunction Self "new" new.
  End Impl_move_binary_format_normalized_Bytecode.
  
  Module Impl_core_fmt_Display_for_move_binary_format_normalized_Type.
    Definition Self : Ty.t := Ty.path "move_binary_format::normalized::Type".
    
    (*
        fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
            match self {
                Type::Struct {
                    address,
                    module,
                    name,
                    type_arguments,
                } => {
                    write!(
                        f,
                        "0x{}::{}::{}",
                        address.short_str_lossless(),
                        module,
                        name
                    )?;
                    if let Some(first_ty) = type_arguments.first() {
                        write!(f, "<")?;
                        write!(f, "{}", first_ty)?;
                        for ty in type_arguments.iter().skip(1) {
                            write!(f, ", {}", ty)?;
                        }
                        write!(f, ">")?;
                    }
                    Ok(())
                }
                Type::Vector(ty) => write!(f, "vector<{}>", ty),
                Type::U8 => write!(f, "u8"),
                Type::U16 => write!(f, "u16"),
                Type::U32 => write!(f, "u32"),
                Type::U64 => write!(f, "u64"),
                Type::U128 => write!(f, "u128"),
                Type::U256 => write!(f, "u256"),
                Type::Address => write!(f, "address"),
                Type::Signer => write!(f, "signer"),
                Type::Bool => write!(f, "bool"),
                Type::Reference(r) => write!(f, "&{}", r),
                Type::MutableReference(r) => write!(f, "&mut {}", r),
                Type::TypeParameter(i) => write!(f, "T{:?}", i),
            }
        }
    *)
    Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; f ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let f := M.alloc (| f |) in
          M.catch_return (|
            ltac:(M.monadic
              (M.read (|
                M.match_operator (|
                  self,
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_record_field (|
                            γ,
                            "move_binary_format::normalized::Type::Struct",
                            "address"
                          |) in
                        let γ1_1 :=
                          M.SubPointer.get_struct_record_field (|
                            γ,
                            "move_binary_format::normalized::Type::Struct",
                            "module"
                          |) in
                        let γ1_2 :=
                          M.SubPointer.get_struct_record_field (|
                            γ,
                            "move_binary_format::normalized::Type::Struct",
                            "name"
                          |) in
                        let γ1_3 :=
                          M.SubPointer.get_struct_record_field (|
                            γ,
                            "move_binary_format::normalized::Type::Struct",
                            "type_arguments"
                          |) in
                        let address := M.alloc (| γ1_0 |) in
                        let module := M.alloc (| γ1_1 |) in
                        let name := M.alloc (| γ1_2 |) in
                        let type_arguments := M.alloc (| γ1_3 |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::ops::try_trait::Try",
                                  Ty.apply
                                    (Ty.path "core::result::Result")
                                    []
                                    [ Ty.tuple []; Ty.path "core::fmt::Error" ],
                                  [],
                                  "branch",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "core::fmt::Formatter",
                                      "write_fmt",
                                      []
                                    |),
                                    [
                                      M.read (| f |);
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.path "core::fmt::Arguments",
                                          "new_v1",
                                          []
                                        |),
                                        [
                                          M.alloc (|
                                            Value.Array
                                              [
                                                M.read (| Value.String "0x" |);
                                                M.read (| Value.String "::" |);
                                                M.read (| Value.String "::" |)
                                              ]
                                          |);
                                          M.alloc (|
                                            Value.Array
                                              [
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "core::fmt::rt::Argument",
                                                    "new_display",
                                                    [ Ty.path "alloc::string::String" ]
                                                  |),
                                                  [
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_associated_function (|
                                                          Ty.path
                                                            "move_core_types::account_address::AccountAddress",
                                                          "short_str_lossless",
                                                          []
                                                        |),
                                                        [ M.read (| address |) ]
                                                      |)
                                                    |)
                                                  ]
                                                |);
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "core::fmt::rt::Argument",
                                                    "new_display",
                                                    [
                                                      Ty.apply
                                                        (Ty.path "&")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_core_types::identifier::Identifier"
                                                        ]
                                                    ]
                                                  |),
                                                  [ module ]
                                                |);
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "core::fmt::rt::Argument",
                                                    "new_display",
                                                    [
                                                      Ty.apply
                                                        (Ty.path "&")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_core_types::identifier::Identifier"
                                                        ]
                                                    ]
                                                  |),
                                                  [ name ]
                                                |)
                                              ]
                                          |)
                                        ]
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ0_0 :=
                                    M.SubPointer.get_struct_tuple_field (|
                                      γ,
                                      "core::ops::control_flow::ControlFlow::Break",
                                      0
                                    |) in
                                  let residual := M.copy (| γ0_0 |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::ops::try_trait::FromResidual",
                                              Ty.apply
                                                (Ty.path "core::result::Result")
                                                []
                                                [ Ty.tuple []; Ty.path "core::fmt::Error" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::result::Result")
                                                  []
                                                  [
                                                    Ty.path "core::convert::Infallible";
                                                    Ty.path "core::fmt::Error"
                                                  ]
                                              ],
                                              "from_residual",
                                              []
                                            |),
                                            [ M.read (| residual |) ]
                                          |)
                                        |)
                                      |)
                                    |)
                                  |)));
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ0_0 :=
                                    M.SubPointer.get_struct_tuple_field (|
                                      γ,
                                      "core::ops::control_flow::ControlFlow::Continue",
                                      0
                                    |) in
                                  let val := M.copy (| γ0_0 |) in
                                  val))
                            ]
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ :=
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.apply
                                            (Ty.path "slice")
                                            []
                                            [ Ty.path "move_binary_format::normalized::Type" ],
                                          "first",
                                          []
                                        |),
                                        [
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::ops::deref::Deref",
                                              Ty.apply
                                                (Ty.path "alloc::vec::Vec")
                                                []
                                                [
                                                  Ty.path "move_binary_format::normalized::Type";
                                                  Ty.path "alloc::alloc::Global"
                                                ],
                                              [],
                                              "deref",
                                              []
                                            |),
                                            [ M.read (| type_arguments |) ]
                                          |)
                                        ]
                                      |)
                                    |) in
                                  let γ0_0 :=
                                    M.SubPointer.get_struct_tuple_field (|
                                      γ,
                                      "core::option::Option::Some",
                                      0
                                    |) in
                                  let first_ty := M.copy (| γ0_0 |) in
                                  let~ _ :=
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::ops::try_trait::Try",
                                            Ty.apply
                                              (Ty.path "core::result::Result")
                                              []
                                              [ Ty.tuple []; Ty.path "core::fmt::Error" ],
                                            [],
                                            "branch",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path "core::fmt::Formatter",
                                                "write_fmt",
                                                []
                                              |),
                                              [
                                                M.read (| f |);
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "core::fmt::Arguments",
                                                    "new_const",
                                                    []
                                                  |),
                                                  [
                                                    M.alloc (|
                                                      Value.Array [ M.read (| Value.String "<" |) ]
                                                    |)
                                                  ]
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ0_0 :=
                                              M.SubPointer.get_struct_tuple_field (|
                                                γ,
                                                "core::ops::control_flow::ControlFlow::Break",
                                                0
                                              |) in
                                            let residual := M.copy (| γ0_0 |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    M.call_closure (|
                                                      M.get_trait_method (|
                                                        "core::ops::try_trait::FromResidual",
                                                        Ty.apply
                                                          (Ty.path "core::result::Result")
                                                          []
                                                          [ Ty.tuple []; Ty.path "core::fmt::Error"
                                                          ],
                                                        [
                                                          Ty.apply
                                                            (Ty.path "core::result::Result")
                                                            []
                                                            [
                                                              Ty.path "core::convert::Infallible";
                                                              Ty.path "core::fmt::Error"
                                                            ]
                                                        ],
                                                        "from_residual",
                                                        []
                                                      |),
                                                      [ M.read (| residual |) ]
                                                    |)
                                                  |)
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ0_0 :=
                                              M.SubPointer.get_struct_tuple_field (|
                                                γ,
                                                "core::ops::control_flow::ControlFlow::Continue",
                                                0
                                              |) in
                                            let val := M.copy (| γ0_0 |) in
                                            val))
                                      ]
                                    |) in
                                  let~ _ :=
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::ops::try_trait::Try",
                                            Ty.apply
                                              (Ty.path "core::result::Result")
                                              []
                                              [ Ty.tuple []; Ty.path "core::fmt::Error" ],
                                            [],
                                            "branch",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path "core::fmt::Formatter",
                                                "write_fmt",
                                                []
                                              |),
                                              [
                                                M.read (| f |);
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "core::fmt::Arguments",
                                                    "new_v1",
                                                    []
                                                  |),
                                                  [
                                                    M.alloc (|
                                                      Value.Array [ M.read (| Value.String "" |) ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Argument",
                                                              "new_display",
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "&")
                                                                  []
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::normalized::Type"
                                                                  ]
                                                              ]
                                                            |),
                                                            [ first_ty ]
                                                          |)
                                                        ]
                                                    |)
                                                  ]
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ0_0 :=
                                              M.SubPointer.get_struct_tuple_field (|
                                                γ,
                                                "core::ops::control_flow::ControlFlow::Break",
                                                0
                                              |) in
                                            let residual := M.copy (| γ0_0 |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    M.call_closure (|
                                                      M.get_trait_method (|
                                                        "core::ops::try_trait::FromResidual",
                                                        Ty.apply
                                                          (Ty.path "core::result::Result")
                                                          []
                                                          [ Ty.tuple []; Ty.path "core::fmt::Error"
                                                          ],
                                                        [
                                                          Ty.apply
                                                            (Ty.path "core::result::Result")
                                                            []
                                                            [
                                                              Ty.path "core::convert::Infallible";
                                                              Ty.path "core::fmt::Error"
                                                            ]
                                                        ],
                                                        "from_residual",
                                                        []
                                                      |),
                                                      [ M.read (| residual |) ]
                                                    |)
                                                  |)
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ0_0 :=
                                              M.SubPointer.get_struct_tuple_field (|
                                                γ,
                                                "core::ops::control_flow::ControlFlow::Continue",
                                                0
                                              |) in
                                            let val := M.copy (| γ0_0 |) in
                                            val))
                                      ]
                                    |) in
                                  let~ _ :=
                                    M.use
                                      (M.match_operator (|
                                        M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::iter::traits::collect::IntoIterator",
                                              Ty.apply
                                                (Ty.path "core::iter::adapters::skip::Skip")
                                                []
                                                [
                                                  Ty.apply
                                                    (Ty.path "core::slice::iter::Iter")
                                                    []
                                                    [ Ty.path "move_binary_format::normalized::Type"
                                                    ]
                                                ],
                                              [],
                                              "into_iter",
                                              []
                                            |),
                                            [
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::iter::traits::iterator::Iterator",
                                                  Ty.apply
                                                    (Ty.path "core::slice::iter::Iter")
                                                    []
                                                    [ Ty.path "move_binary_format::normalized::Type"
                                                    ],
                                                  [],
                                                  "skip",
                                                  []
                                                |),
                                                [
                                                  M.call_closure (|
                                                    M.get_associated_function (|
                                                      Ty.apply
                                                        (Ty.path "slice")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_binary_format::normalized::Type"
                                                        ],
                                                      "iter",
                                                      []
                                                    |),
                                                    [
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::ops::deref::Deref",
                                                          Ty.apply
                                                            (Ty.path "alloc::vec::Vec")
                                                            []
                                                            [
                                                              Ty.path
                                                                "move_binary_format::normalized::Type";
                                                              Ty.path "alloc::alloc::Global"
                                                            ],
                                                          [],
                                                          "deref",
                                                          []
                                                        |),
                                                        [ M.read (| type_arguments |) ]
                                                      |)
                                                    ]
                                                  |);
                                                  Value.Integer IntegerKind.Usize 1
                                                ]
                                              |)
                                            ]
                                          |)
                                        |),
                                        [
                                          fun γ =>
                                            ltac:(M.monadic
                                              (let iter := M.copy (| γ |) in
                                              M.loop (|
                                                ltac:(M.monadic
                                                  (let~ _ :=
                                                    M.match_operator (|
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::iter::traits::iterator::Iterator",
                                                            Ty.apply
                                                              (Ty.path
                                                                "core::iter::adapters::skip::Skip")
                                                              []
                                                              [
                                                                Ty.apply
                                                                  (Ty.path
                                                                    "core::slice::iter::Iter")
                                                                  []
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::normalized::Type"
                                                                  ]
                                                              ],
                                                            [],
                                                            "next",
                                                            []
                                                          |),
                                                          [ iter ]
                                                        |)
                                                      |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let _ :=
                                                              M.is_struct_tuple (|
                                                                γ,
                                                                "core::option::Option::None"
                                                              |) in
                                                            M.alloc (|
                                                              M.never_to_any (|
                                                                M.read (| M.break (||) |)
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ0_0 :=
                                                              M.SubPointer.get_struct_tuple_field (|
                                                                γ,
                                                                "core::option::Option::Some",
                                                                0
                                                              |) in
                                                            let ty := M.copy (| γ0_0 |) in
                                                            let~ _ :=
                                                              M.match_operator (|
                                                                M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::ops::try_trait::Try",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::result::Result")
                                                                        []
                                                                        [
                                                                          Ty.tuple [];
                                                                          Ty.path "core::fmt::Error"
                                                                        ],
                                                                      [],
                                                                      "branch",
                                                                      []
                                                                    |),
                                                                    [
                                                                      M.call_closure (|
                                                                        M.get_associated_function (|
                                                                          Ty.path
                                                                            "core::fmt::Formatter",
                                                                          "write_fmt",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.read (| f |);
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::Arguments",
                                                                              "new_v1",
                                                                              []
                                                                            |),
                                                                            [
                                                                              M.alloc (|
                                                                                Value.Array
                                                                                  [
                                                                                    M.read (|
                                                                                      Value.String
                                                                                        ", "
                                                                                    |)
                                                                                  ]
                                                                              |);
                                                                              M.alloc (|
                                                                                Value.Array
                                                                                  [
                                                                                    M.call_closure (|
                                                                                      M.get_associated_function (|
                                                                                        Ty.path
                                                                                          "core::fmt::rt::Argument",
                                                                                        "new_display",
                                                                                        [
                                                                                          Ty.apply
                                                                                            (Ty.path
                                                                                              "&")
                                                                                            []
                                                                                            [
                                                                                              Ty.path
                                                                                                "move_binary_format::normalized::Type"
                                                                                            ]
                                                                                        ]
                                                                                      |),
                                                                                      [ ty ]
                                                                                    |)
                                                                                  ]
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |),
                                                                [
                                                                  fun γ =>
                                                                    ltac:(M.monadic
                                                                      (let γ0_0 :=
                                                                        M.SubPointer.get_struct_tuple_field (|
                                                                          γ,
                                                                          "core::ops::control_flow::ControlFlow::Break",
                                                                          0
                                                                        |) in
                                                                      let residual :=
                                                                        M.copy (| γ0_0 |) in
                                                                      M.alloc (|
                                                                        M.never_to_any (|
                                                                          M.read (|
                                                                            M.return_ (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::ops::try_trait::FromResidual",
                                                                                  Ty.apply
                                                                                    (Ty.path
                                                                                      "core::result::Result")
                                                                                    []
                                                                                    [
                                                                                      Ty.tuple [];
                                                                                      Ty.path
                                                                                        "core::fmt::Error"
                                                                                    ],
                                                                                  [
                                                                                    Ty.apply
                                                                                      (Ty.path
                                                                                        "core::result::Result")
                                                                                      []
                                                                                      [
                                                                                        Ty.path
                                                                                          "core::convert::Infallible";
                                                                                        Ty.path
                                                                                          "core::fmt::Error"
                                                                                      ]
                                                                                  ],
                                                                                  "from_residual",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  M.read (|
                                                                                    residual
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)
                                                                          |)
                                                                        |)
                                                                      |)));
                                                                  fun γ =>
                                                                    ltac:(M.monadic
                                                                      (let γ0_0 :=
                                                                        M.SubPointer.get_struct_tuple_field (|
                                                                          γ,
                                                                          "core::ops::control_flow::ControlFlow::Continue",
                                                                          0
                                                                        |) in
                                                                      let val :=
                                                                        M.copy (| γ0_0 |) in
                                                                      val))
                                                                ]
                                                              |) in
                                                            M.alloc (| Value.Tuple [] |)))
                                                      ]
                                                    |) in
                                                  M.alloc (| Value.Tuple [] |)))
                                              |)))
                                        ]
                                      |)) in
                                  let~ _ :=
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::ops::try_trait::Try",
                                            Ty.apply
                                              (Ty.path "core::result::Result")
                                              []
                                              [ Ty.tuple []; Ty.path "core::fmt::Error" ],
                                            [],
                                            "branch",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path "core::fmt::Formatter",
                                                "write_fmt",
                                                []
                                              |),
                                              [
                                                M.read (| f |);
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "core::fmt::Arguments",
                                                    "new_const",
                                                    []
                                                  |),
                                                  [
                                                    M.alloc (|
                                                      Value.Array [ M.read (| Value.String ">" |) ]
                                                    |)
                                                  ]
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ0_0 :=
                                              M.SubPointer.get_struct_tuple_field (|
                                                γ,
                                                "core::ops::control_flow::ControlFlow::Break",
                                                0
                                              |) in
                                            let residual := M.copy (| γ0_0 |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    M.call_closure (|
                                                      M.get_trait_method (|
                                                        "core::ops::try_trait::FromResidual",
                                                        Ty.apply
                                                          (Ty.path "core::result::Result")
                                                          []
                                                          [ Ty.tuple []; Ty.path "core::fmt::Error"
                                                          ],
                                                        [
                                                          Ty.apply
                                                            (Ty.path "core::result::Result")
                                                            []
                                                            [
                                                              Ty.path "core::convert::Infallible";
                                                              Ty.path "core::fmt::Error"
                                                            ]
                                                        ],
                                                        "from_residual",
                                                        []
                                                      |),
                                                      [ M.read (| residual |) ]
                                                    |)
                                                  |)
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ0_0 :=
                                              M.SubPointer.get_struct_tuple_field (|
                                                γ,
                                                "core::ops::control_flow::ControlFlow::Continue",
                                                0
                                              |) in
                                            let val := M.copy (| γ0_0 |) in
                                            val))
                                      ]
                                    |) in
                                  M.alloc (| Value.Tuple [] |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) in
                        M.alloc (|
                          Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::normalized::Type::Vector",
                            0
                          |) in
                        let ty := M.alloc (| γ1_0 |) in
                        M.alloc (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "core::fmt::Formatter",
                              "write_fmt",
                              []
                            |),
                            [
                              M.read (| f |);
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "core::fmt::Arguments",
                                  "new_v1",
                                  []
                                |),
                                [
                                  M.alloc (|
                                    Value.Array
                                      [
                                        M.read (| Value.String "vector<" |);
                                        M.read (| Value.String ">" |)
                                      ]
                                  |);
                                  M.alloc (|
                                    Value.Array
                                      [
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "core::fmt::rt::Argument",
                                            "new_display",
                                            [
                                              Ty.apply
                                                (Ty.path "&")
                                                []
                                                [
                                                  Ty.apply
                                                    (Ty.path "alloc::boxed::Box")
                                                    []
                                                    [
                                                      Ty.path
                                                        "move_binary_format::normalized::Type";
                                                      Ty.path "alloc::alloc::Global"
                                                    ]
                                                ]
                                            ]
                                          |),
                                          [ ty ]
                                        |)
                                      ]
                                  |)
                                ]
                              |)
                            ]
                          |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U8" |) in
                        M.alloc (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "core::fmt::Formatter",
                              "write_fmt",
                              []
                            |),
                            [
                              M.read (| f |);
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "core::fmt::Arguments",
                                  "new_const",
                                  []
                                |),
                                [ M.alloc (| Value.Array [ M.read (| Value.String "u8" |) ] |) ]
                              |)
                            ]
                          |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U16" |) in
                        M.alloc (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "core::fmt::Formatter",
                              "write_fmt",
                              []
                            |),
                            [
                              M.read (| f |);
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "core::fmt::Arguments",
                                  "new_const",
                                  []
                                |),
                                [ M.alloc (| Value.Array [ M.read (| Value.String "u16" |) ] |) ]
                              |)
                            ]
                          |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U32" |) in
                        M.alloc (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "core::fmt::Formatter",
                              "write_fmt",
                              []
                            |),
                            [
                              M.read (| f |);
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "core::fmt::Arguments",
                                  "new_const",
                                  []
                                |),
                                [ M.alloc (| Value.Array [ M.read (| Value.String "u32" |) ] |) ]
                              |)
                            ]
                          |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U64" |) in
                        M.alloc (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "core::fmt::Formatter",
                              "write_fmt",
                              []
                            |),
                            [
                              M.read (| f |);
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "core::fmt::Arguments",
                                  "new_const",
                                  []
                                |),
                                [ M.alloc (| Value.Array [ M.read (| Value.String "u64" |) ] |) ]
                              |)
                            ]
                          |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U128" |) in
                        M.alloc (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "core::fmt::Formatter",
                              "write_fmt",
                              []
                            |),
                            [
                              M.read (| f |);
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "core::fmt::Arguments",
                                  "new_const",
                                  []
                                |),
                                [ M.alloc (| Value.Array [ M.read (| Value.String "u128" |) ] |) ]
                              |)
                            ]
                          |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::U256" |) in
                        M.alloc (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "core::fmt::Formatter",
                              "write_fmt",
                              []
                            |),
                            [
                              M.read (| f |);
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "core::fmt::Arguments",
                                  "new_const",
                                  []
                                |),
                                [ M.alloc (| Value.Array [ M.read (| Value.String "u256" |) ] |) ]
                              |)
                            ]
                          |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (|
                            γ,
                            "move_binary_format::normalized::Type::Address"
                          |) in
                        M.alloc (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "core::fmt::Formatter",
                              "write_fmt",
                              []
                            |),
                            [
                              M.read (| f |);
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "core::fmt::Arguments",
                                  "new_const",
                                  []
                                |),
                                [ M.alloc (| Value.Array [ M.read (| Value.String "address" |) ] |)
                                ]
                              |)
                            ]
                          |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (|
                            γ,
                            "move_binary_format::normalized::Type::Signer"
                          |) in
                        M.alloc (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "core::fmt::Formatter",
                              "write_fmt",
                              []
                            |),
                            [
                              M.read (| f |);
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "core::fmt::Arguments",
                                  "new_const",
                                  []
                                |),
                                [ M.alloc (| Value.Array [ M.read (| Value.String "signer" |) ] |) ]
                              |)
                            ]
                          |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (| γ, "move_binary_format::normalized::Type::Bool" |) in
                        M.alloc (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "core::fmt::Formatter",
                              "write_fmt",
                              []
                            |),
                            [
                              M.read (| f |);
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "core::fmt::Arguments",
                                  "new_const",
                                  []
                                |),
                                [ M.alloc (| Value.Array [ M.read (| Value.String "bool" |) ] |) ]
                              |)
                            ]
                          |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::normalized::Type::Reference",
                            0
                          |) in
                        let r := M.alloc (| γ1_0 |) in
                        M.alloc (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "core::fmt::Formatter",
                              "write_fmt",
                              []
                            |),
                            [
                              M.read (| f |);
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "core::fmt::Arguments",
                                  "new_v1",
                                  []
                                |),
                                [
                                  M.alloc (| Value.Array [ M.read (| Value.String "&" |) ] |);
                                  M.alloc (|
                                    Value.Array
                                      [
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "core::fmt::rt::Argument",
                                            "new_display",
                                            [
                                              Ty.apply
                                                (Ty.path "&")
                                                []
                                                [
                                                  Ty.apply
                                                    (Ty.path "alloc::boxed::Box")
                                                    []
                                                    [
                                                      Ty.path
                                                        "move_binary_format::normalized::Type";
                                                      Ty.path "alloc::alloc::Global"
                                                    ]
                                                ]
                                            ]
                                          |),
                                          [ r ]
                                        |)
                                      ]
                                  |)
                                ]
                              |)
                            ]
                          |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::normalized::Type::MutableReference",
                            0
                          |) in
                        let r := M.alloc (| γ1_0 |) in
                        M.alloc (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "core::fmt::Formatter",
                              "write_fmt",
                              []
                            |),
                            [
                              M.read (| f |);
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "core::fmt::Arguments",
                                  "new_v1",
                                  []
                                |),
                                [
                                  M.alloc (| Value.Array [ M.read (| Value.String "&mut " |) ] |);
                                  M.alloc (|
                                    Value.Array
                                      [
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "core::fmt::rt::Argument",
                                            "new_display",
                                            [
                                              Ty.apply
                                                (Ty.path "&")
                                                []
                                                [
                                                  Ty.apply
                                                    (Ty.path "alloc::boxed::Box")
                                                    []
                                                    [
                                                      Ty.path
                                                        "move_binary_format::normalized::Type";
                                                      Ty.path "alloc::alloc::Global"
                                                    ]
                                                ]
                                            ]
                                          |),
                                          [ r ]
                                        |)
                                      ]
                                  |)
                                ]
                              |)
                            ]
                          |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::normalized::Type::TypeParameter",
                            0
                          |) in
                        let i := M.alloc (| γ1_0 |) in
                        M.alloc (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "core::fmt::Formatter",
                              "write_fmt",
                              []
                            |),
                            [
                              M.read (| f |);
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "core::fmt::Arguments",
                                  "new_v1",
                                  []
                                |),
                                [
                                  M.alloc (| Value.Array [ M.read (| Value.String "T" |) ] |);
                                  M.alloc (|
                                    Value.Array
                                      [
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "core::fmt::rt::Argument",
                                            "new_debug",
                                            [ Ty.apply (Ty.path "&") [] [ Ty.path "u16" ] ]
                                          |),
                                          [ i ]
                                        |)
                                      ]
                                  |)
                                ]
                              |)
                            ]
                          |)
                        |)))
                  ]
                |)
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::fmt::Display"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
  End Impl_core_fmt_Display_for_move_binary_format_normalized_Type.
  
  (*
  fn struct_instantiation(
      m: &CompiledModule,
      si_idx: &StructDefInstantiationIndex,
  ) -> (Identifier, Vec<Type>) {
      let StructDefInstantiation {
          def,
          type_parameters,
      } = m.struct_instantiation_at( *si_idx);
      let (name, _) = Struct::new(m, m.struct_def_at( *def));
      let types = m
          .signature_at( *type_parameters)
          .0
          .iter()
          .map(|tok| Type::new(m, tok))
          .collect();
      (name, types)
  }
  *)
  Definition struct_instantiation (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [], [ m; si_idx ] =>
      ltac:(M.monadic
        (let m := M.alloc (| m |) in
        let si_idx := M.alloc (| si_idx |) in
        M.read (|
          M.match_operator (|
            M.alloc (|
              M.call_closure (|
                M.get_associated_function (|
                  Ty.path "move_binary_format::file_format::CompiledModule",
                  "struct_instantiation_at",
                  []
                |),
                [ M.read (| m |); M.read (| M.read (| si_idx |) |) ]
              |)
            |),
            [
              fun γ =>
                ltac:(M.monadic
                  (let γ := M.read (| γ |) in
                  let γ1_0 :=
                    M.SubPointer.get_struct_record_field (|
                      γ,
                      "move_binary_format::file_format::StructDefInstantiation",
                      "def"
                    |) in
                  let γ1_1 :=
                    M.SubPointer.get_struct_record_field (|
                      γ,
                      "move_binary_format::file_format::StructDefInstantiation",
                      "type_parameters"
                    |) in
                  let def := M.alloc (| γ1_0 |) in
                  let type_parameters := M.alloc (| γ1_1 |) in
                  M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "move_binary_format::normalized::Struct",
                          "new",
                          []
                        |),
                        [
                          M.read (| m |);
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "move_binary_format::file_format::CompiledModule",
                              "struct_def_at",
                              []
                            |),
                            [ M.read (| m |); M.read (| M.read (| def |) |) ]
                          |)
                        ]
                      |)
                    |),
                    [
                      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 name := M.copy (| γ0_0 |) in
                          let~ types :=
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::iter::traits::iterator::Iterator",
                                  Ty.apply
                                    (Ty.path "core::iter::adapters::map::Map")
                                    []
                                    [
                                      Ty.apply
                                        (Ty.path "core::slice::iter::Iter")
                                        []
                                        [ Ty.path "move_binary_format::file_format::SignatureToken"
                                        ];
                                      Ty.function
                                        [
                                          Ty.tuple
                                            [
                                              Ty.apply
                                                (Ty.path "&")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::SignatureToken"
                                                ]
                                            ]
                                        ]
                                        (Ty.path "move_binary_format::normalized::Type")
                                    ],
                                  [],
                                  "collect",
                                  [
                                    Ty.apply
                                      (Ty.path "alloc::vec::Vec")
                                      []
                                      [
                                        Ty.path "move_binary_format::normalized::Type";
                                        Ty.path "alloc::alloc::Global"
                                      ]
                                  ]
                                |),
                                [
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::iter::traits::iterator::Iterator",
                                      Ty.apply
                                        (Ty.path "core::slice::iter::Iter")
                                        []
                                        [ Ty.path "move_binary_format::file_format::SignatureToken"
                                        ],
                                      [],
                                      "map",
                                      [
                                        Ty.path "move_binary_format::normalized::Type";
                                        Ty.function
                                          [
                                            Ty.tuple
                                              [
                                                Ty.apply
                                                  (Ty.path "&")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_binary_format::file_format::SignatureToken"
                                                  ]
                                              ]
                                          ]
                                          (Ty.path "move_binary_format::normalized::Type")
                                      ]
                                    |),
                                    [
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.apply
                                            (Ty.path "slice")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken"
                                            ],
                                          "iter",
                                          []
                                        |),
                                        [
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::ops::deref::Deref",
                                              Ty.apply
                                                (Ty.path "alloc::vec::Vec")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::SignatureToken";
                                                  Ty.path "alloc::alloc::Global"
                                                ],
                                              [],
                                              "deref",
                                              []
                                            |),
                                            [
                                              M.SubPointer.get_struct_tuple_field (|
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path
                                                      "move_binary_format::file_format::CompiledModule",
                                                    "signature_at",
                                                    []
                                                  |),
                                                  [
                                                    M.read (| m |);
                                                    M.read (| M.read (| type_parameters |) |)
                                                  ]
                                                |),
                                                "move_binary_format::file_format::Signature",
                                                0
                                              |)
                                            ]
                                          |)
                                        ]
                                      |);
                                      M.closure
                                        (fun γ =>
                                          ltac:(M.monadic
                                            match γ with
                                            | [ α0 ] =>
                                              ltac:(M.monadic
                                                (M.match_operator (|
                                                  M.alloc (| α0 |),
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let tok := M.copy (| γ |) in
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_binary_format::normalized::Type",
                                                            "new",
                                                            []
                                                          |),
                                                          [ M.read (| m |); M.read (| tok |) ]
                                                        |)))
                                                  ]
                                                |)))
                                            | _ => M.impossible "wrong number of arguments"
                                            end))
                                    ]
                                  |)
                                ]
                              |)
                            |) in
                          M.alloc (| Value.Tuple [ M.read (| name |); M.read (| types |) ] |)))
                    ]
                  |)))
            ]
          |)
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_struct_instantiation :
    M.IsFunction "move_binary_format::normalized::struct_instantiation" struct_instantiation.
  
  (*
  fn field_instantiation(m: &CompiledModule, idx: &FieldInstantiationIndex) -> (FieldRef, Vec<Type>) {
      let FieldInstantiation {
          handle,
          type_parameters,
      } = m.field_instantiation_at( *idx);
      let field_ref = FieldRef::new(m, m.field_handle_at( *handle));
      let types = m
          .signature_at( *type_parameters)
          .0
          .iter()
          .map(|tok| Type::new(m, tok))
          .collect();
      (field_ref, types)
  }
  *)
  Definition field_instantiation (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [], [ m; idx ] =>
      ltac:(M.monadic
        (let m := M.alloc (| m |) in
        let idx := M.alloc (| idx |) in
        M.read (|
          M.match_operator (|
            M.alloc (|
              M.call_closure (|
                M.get_associated_function (|
                  Ty.path "move_binary_format::file_format::CompiledModule",
                  "field_instantiation_at",
                  []
                |),
                [ M.read (| m |); M.read (| M.read (| idx |) |) ]
              |)
            |),
            [
              fun γ =>
                ltac:(M.monadic
                  (let γ := M.read (| γ |) in
                  let γ1_0 :=
                    M.SubPointer.get_struct_record_field (|
                      γ,
                      "move_binary_format::file_format::FieldInstantiation",
                      "handle"
                    |) in
                  let γ1_1 :=
                    M.SubPointer.get_struct_record_field (|
                      γ,
                      "move_binary_format::file_format::FieldInstantiation",
                      "type_parameters"
                    |) in
                  let handle := M.alloc (| γ1_0 |) in
                  let type_parameters := M.alloc (| γ1_1 |) in
                  let~ field_ref :=
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "move_binary_format::normalized::FieldRef",
                          "new",
                          []
                        |),
                        [
                          M.read (| m |);
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "move_binary_format::file_format::CompiledModule",
                              "field_handle_at",
                              []
                            |),
                            [ M.read (| m |); M.read (| M.read (| handle |) |) ]
                          |)
                        ]
                      |)
                    |) in
                  let~ types :=
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::iter::traits::iterator::Iterator",
                          Ty.apply
                            (Ty.path "core::iter::adapters::map::Map")
                            []
                            [
                              Ty.apply
                                (Ty.path "core::slice::iter::Iter")
                                []
                                [ Ty.path "move_binary_format::file_format::SignatureToken" ];
                              Ty.function
                                [
                                  Ty.tuple
                                    [
                                      Ty.apply
                                        (Ty.path "&")
                                        []
                                        [ Ty.path "move_binary_format::file_format::SignatureToken"
                                        ]
                                    ]
                                ]
                                (Ty.path "move_binary_format::normalized::Type")
                            ],
                          [],
                          "collect",
                          [
                            Ty.apply
                              (Ty.path "alloc::vec::Vec")
                              []
                              [
                                Ty.path "move_binary_format::normalized::Type";
                                Ty.path "alloc::alloc::Global"
                              ]
                          ]
                        |),
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::iter::traits::iterator::Iterator",
                              Ty.apply
                                (Ty.path "core::slice::iter::Iter")
                                []
                                [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                              [],
                              "map",
                              [
                                Ty.path "move_binary_format::normalized::Type";
                                Ty.function
                                  [
                                    Ty.tuple
                                      [
                                        Ty.apply
                                          (Ty.path "&")
                                          []
                                          [
                                            Ty.path
                                              "move_binary_format::file_format::SignatureToken"
                                          ]
                                      ]
                                  ]
                                  (Ty.path "move_binary_format::normalized::Type")
                              ]
                            |),
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.apply
                                    (Ty.path "slice")
                                    []
                                    [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                  "iter",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::ops::deref::Deref",
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::file_format::SignatureToken";
                                          Ty.path "alloc::alloc::Global"
                                        ],
                                      [],
                                      "deref",
                                      []
                                    |),
                                    [
                                      M.SubPointer.get_struct_tuple_field (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path
                                              "move_binary_format::file_format::CompiledModule",
                                            "signature_at",
                                            []
                                          |),
                                          [
                                            M.read (| m |);
                                            M.read (| M.read (| type_parameters |) |)
                                          ]
                                        |),
                                        "move_binary_format::file_format::Signature",
                                        0
                                      |)
                                    ]
                                  |)
                                ]
                              |);
                              M.closure
                                (fun γ =>
                                  ltac:(M.monadic
                                    match γ with
                                    | [ α0 ] =>
                                      ltac:(M.monadic
                                        (M.match_operator (|
                                          M.alloc (| α0 |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let tok := M.copy (| γ |) in
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "move_binary_format::normalized::Type",
                                                    "new",
                                                    []
                                                  |),
                                                  [ M.read (| m |); M.read (| tok |) ]
                                                |)))
                                          ]
                                        |)))
                                    | _ => M.impossible "wrong number of arguments"
                                    end))
                            ]
                          |)
                        ]
                      |)
                    |) in
                  M.alloc (| Value.Tuple [ M.read (| field_ref |); M.read (| types |) ] |)))
            ]
          |)
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_field_instantiation :
    M.IsFunction "move_binary_format::normalized::field_instantiation" field_instantiation.
  
  (*
  fn signature_to_single_type(m: &CompiledModule, sig_idx: &SignatureIndex) -> Type {
      Type::new(m, &m.signature_at( *sig_idx).0[0])
  }
  *)
  Definition signature_to_single_type (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [], [ m; sig_idx ] =>
      ltac:(M.monadic
        (let m := M.alloc (| m |) in
        let sig_idx := M.alloc (| sig_idx |) in
        M.call_closure (|
          M.get_associated_function (| Ty.path "move_binary_format::normalized::Type", "new", [] |),
          [
            M.read (| m |);
            M.call_closure (|
              M.get_trait_method (|
                "core::ops::index::Index",
                Ty.apply
                  (Ty.path "alloc::vec::Vec")
                  []
                  [
                    Ty.path "move_binary_format::file_format::SignatureToken";
                    Ty.path "alloc::alloc::Global"
                  ],
                [ Ty.path "usize" ],
                "index",
                []
              |),
              [
                M.SubPointer.get_struct_tuple_field (|
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "move_binary_format::file_format::CompiledModule",
                      "signature_at",
                      []
                    |),
                    [ M.read (| m |); M.read (| M.read (| sig_idx |) |) ]
                  |),
                  "move_binary_format::file_format::Signature",
                  0
                |);
                Value.Integer IntegerKind.Usize 0
              ]
            |)
          ]
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_signature_to_single_type :
    M.IsFunction
      "move_binary_format::normalized::signature_to_single_type"
      signature_to_single_type.
End normalized.
