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

Module transaction_argument.
  (*
  Enum TransactionArgument
  {
    const_params := [];
    ty_params := [];
    variants :=
      [
        {
          name := "U8";
          item := StructTuple [ Ty.path "u8" ];
          discriminant := None;
        };
        {
          name := "U64";
          item := StructTuple [ Ty.path "u64" ];
          discriminant := None;
        };
        {
          name := "U128";
          item := StructTuple [ Ty.path "u128" ];
          discriminant := None;
        };
        {
          name := "Address";
          item := StructTuple [ Ty.path "move_core_types::account_address::AccountAddress" ];
          discriminant := None;
        };
        {
          name := "U8Vector";
          item :=
            StructTuple
              [
                Ty.apply
                  (Ty.path "alloc::vec::Vec")
                  []
                  [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ]
              ];
          discriminant := None;
        };
        {
          name := "Bool";
          item := StructTuple [ Ty.path "bool" ];
          discriminant := None;
        };
        {
          name := "U16";
          item := StructTuple [ Ty.path "u16" ];
          discriminant := None;
        };
        {
          name := "U32";
          item := StructTuple [ Ty.path "u32" ];
          discriminant := None;
        };
        {
          name := "U256";
          item := StructTuple [ Ty.path "move_core_types::u256::U256" ];
          discriminant := None;
        }
      ];
  }
  *)
  
  Module Impl_core_clone_Clone_for_move_core_types_transaction_argument_TransactionArgument.
    Definition Self : Ty.t := Ty.path "move_core_types::transaction_argument::TransactionArgument".
    
    (* 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 γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U8",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_core_types::transaction_argument::TransactionArgument::U8"
                        [
                          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_core_types::transaction_argument::TransactionArgument::U64",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_core_types::transaction_argument::TransactionArgument::U64"
                        [
                          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_core_types::transaction_argument::TransactionArgument::U128",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_core_types::transaction_argument::TransactionArgument::U128"
                        [
                          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 γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::Address",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_core_types::transaction_argument::TransactionArgument::Address"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_core_types::account_address::AccountAddress",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U8Vector",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_core_types::transaction_argument::TransactionArgument::U8Vector"
                        [
                          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.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::Bool",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_core_types::transaction_argument::TransactionArgument::Bool"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "bool",
                              [],
                              "clone",
                              []
                            |),
                            [ M.read (| __self_0 |) ]
                          |)
                        ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U16",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_core_types::transaction_argument::TransactionArgument::U16"
                        [
                          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_core_types::transaction_argument::TransactionArgument::U32",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_core_types::transaction_argument::TransactionArgument::U32"
                        [
                          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_core_types::transaction_argument::TransactionArgument::U256",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_core_types::transaction_argument::TransactionArgument::U256"
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::clone::Clone",
                              Ty.path "move_core_types::u256::U256",
                              [],
                              "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_core_types_transaction_argument_TransactionArgument.
  
  Module Impl_core_hash_Hash_for_move_core_types_transaction_argument_TransactionArgument.
    Definition Self : Ty.t := Ty.path "move_core_types::transaction_argument::TransactionArgument".
    
    (* Hash *)
    Definition hash (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [ __H ], [ self; state ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let state := M.alloc (| state |) in
          M.read (|
            let~ __self_discr :=
              M.alloc (|
                M.call_closure (|
                  M.get_function (|
                    "core::intrinsics::discriminant_value",
                    [ Ty.path "move_core_types::transaction_argument::TransactionArgument" ]
                  |),
                  [ M.read (| self |) ]
                |)
              |) in
            let~ _ :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::hash::Hash", Ty.path "isize", [], "hash", [ __H ] |),
                  [ __self_discr; M.read (| state |) ]
                |)
              |) in
            M.match_operator (|
              self,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U8",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::hash::Hash",
                          Ty.path "u8",
                          [],
                          "hash",
                          [ __H ]
                        |),
                        [ M.read (| __self_0 |); M.read (| state |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U64",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::hash::Hash",
                          Ty.path "u64",
                          [],
                          "hash",
                          [ __H ]
                        |),
                        [ M.read (| __self_0 |); M.read (| state |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U128",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::hash::Hash",
                          Ty.path "u128",
                          [],
                          "hash",
                          [ __H ]
                        |),
                        [ M.read (| __self_0 |); M.read (| state |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::Address",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::hash::Hash",
                          Ty.path "move_core_types::account_address::AccountAddress",
                          [],
                          "hash",
                          [ __H ]
                        |),
                        [ M.read (| __self_0 |); M.read (| state |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U8Vector",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::hash::Hash",
                          Ty.apply
                            (Ty.path "alloc::vec::Vec")
                            []
                            [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ],
                          [],
                          "hash",
                          [ __H ]
                        |),
                        [ M.read (| __self_0 |); M.read (| state |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::Bool",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::hash::Hash",
                          Ty.path "bool",
                          [],
                          "hash",
                          [ __H ]
                        |),
                        [ M.read (| __self_0 |); M.read (| state |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U16",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::hash::Hash",
                          Ty.path "u16",
                          [],
                          "hash",
                          [ __H ]
                        |),
                        [ M.read (| __self_0 |); M.read (| state |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U32",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::hash::Hash",
                          Ty.path "u32",
                          [],
                          "hash",
                          [ __H ]
                        |),
                        [ M.read (| __self_0 |); M.read (| state |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U256",
                        0
                      |) in
                    let __self_0 := M.alloc (| γ1_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::hash::Hash",
                          Ty.path "move_core_types::u256::U256",
                          [],
                          "hash",
                          [ __H ]
                        |),
                        [ M.read (| __self_0 |); M.read (| state |) ]
                      |)
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::hash::Hash"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("hash", InstanceField.Method hash) ].
  End Impl_core_hash_Hash_for_move_core_types_transaction_argument_TransactionArgument.
  
  Module Impl_core_cmp_Eq_for_move_core_types_transaction_argument_TransactionArgument.
    Definition Self : Ty.t := Ty.path "move_core_types::transaction_argument::TransactionArgument".
    
    (* 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.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_core_types_transaction_argument_TransactionArgument.
  
  Module Impl_core_marker_StructuralPartialEq_for_move_core_types_transaction_argument_TransactionArgument.
    Definition Self : Ty.t := Ty.path "move_core_types::transaction_argument::TransactionArgument".
    
    Axiom Implements :
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_move_core_types_transaction_argument_TransactionArgument.
  
  Module Impl_core_cmp_PartialEq_for_move_core_types_transaction_argument_TransactionArgument.
    Definition Self : Ty.t := Ty.path "move_core_types::transaction_argument::TransactionArgument".
    
    (* 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_core_types::transaction_argument::TransactionArgument" ]
                  |),
                  [ M.read (| self |) ]
                |)
              |) in
            let~ __arg1_discr :=
              M.alloc (|
                M.call_closure (|
                  M.get_function (|
                    "core::intrinsics::discriminant_value",
                    [ Ty.path "move_core_types::transaction_argument::TransactionArgument" ]
                  |),
                  [ 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_core_types::transaction_argument::TransactionArgument::U8",
                                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_core_types::transaction_argument::TransactionArgument::U8",
                                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_core_types::transaction_argument::TransactionArgument::U64",
                                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_core_types::transaction_argument::TransactionArgument::U64",
                                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_core_types::transaction_argument::TransactionArgument::U128",
                                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_core_types::transaction_argument::TransactionArgument::U128",
                                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_core_types::transaction_argument::TransactionArgument::Address",
                                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_core_types::transaction_argument::TransactionArgument::Address",
                                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::account_address::AccountAddress" ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_core_types::account_address::AccountAddress" ]
                                  ],
                                  "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_core_types::transaction_argument::TransactionArgument::U8Vector",
                                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_core_types::transaction_argument::TransactionArgument::U8Vector",
                                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::vec::Vec")
                                        []
                                        [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ]
                                    ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [
                                        Ty.apply
                                          (Ty.path "alloc::vec::Vec")
                                          []
                                          [ Ty.path "u8"; 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_core_types::transaction_argument::TransactionArgument::Bool",
                                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_core_types::transaction_argument::TransactionArgument::Bool",
                                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 "bool" ],
                                  [ Ty.apply (Ty.path "&") [] [ Ty.path "bool" ] ],
                                  "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_core_types::transaction_argument::TransactionArgument::U16",
                                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_core_types::transaction_argument::TransactionArgument::U16",
                                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_core_types::transaction_argument::TransactionArgument::U32",
                                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_core_types::transaction_argument::TransactionArgument::U32",
                                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_core_types::transaction_argument::TransactionArgument::U256",
                                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_core_types::transaction_argument::TransactionArgument::U256",
                                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
                            (M.alloc (|
                              M.never_to_any (|
                                M.call_closure (|
                                  M.get_function (| "core::intrinsics::unreachable", [] |),
                                  []
                                |)
                              |)
                            |)))
                      ]
                    |)
                  |)))
              |)
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::PartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("eq", InstanceField.Method eq) ].
  End Impl_core_cmp_PartialEq_for_move_core_types_transaction_argument_TransactionArgument.
  
  Module underscore.
    Module Impl_serde_ser_Serialize_for_move_core_types_transaction_argument_TransactionArgument.
      Definition Self : Ty.t :=
        Ty.path "move_core_types::transaction_argument::TransactionArgument".
      
      (* 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.read (|
              M.match_operator (|
                M.read (| self |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "move_core_types::transaction_argument::TransactionArgument::U8",
                          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 "TransactionArgument" |);
                            Value.Integer IntegerKind.U32 0;
                            M.read (| Value.String "U8" |);
                            M.read (| __field0 |)
                          ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "move_core_types::transaction_argument::TransactionArgument::U64",
                          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 "TransactionArgument" |);
                            Value.Integer IntegerKind.U32 1;
                            M.read (| Value.String "U64" |);
                            M.read (| __field0 |)
                          ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "move_core_types::transaction_argument::TransactionArgument::U128",
                          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 "TransactionArgument" |);
                            Value.Integer IntegerKind.U32 2;
                            M.read (| Value.String "U128" |);
                            M.read (| __field0 |)
                          ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "move_core_types::transaction_argument::TransactionArgument::Address",
                          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::account_address::AccountAddress" ]
                          |),
                          [
                            M.read (| __serializer |);
                            M.read (| Value.String "TransactionArgument" |);
                            Value.Integer IntegerKind.U32 3;
                            M.read (| Value.String "Address" |);
                            M.read (| __field0 |)
                          ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "move_core_types::transaction_argument::TransactionArgument::U8Vector",
                          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::transaction_argument::_::serialize::__SerializeWith"
                            ]
                          |),
                          [
                            M.read (| __serializer |);
                            M.read (| Value.String "TransactionArgument" |);
                            Value.Integer IntegerKind.U32 4;
                            M.read (| Value.String "U8Vector" |);
                            M.alloc (|
                              Value.StructRecord
                                "move_core_types::transaction_argument::_::serialize::__SerializeWith"
                                [
                                  ("values", Value.Tuple [ M.read (| __field0 |) ]);
                                  ("phantom", Value.StructTuple "core::marker::PhantomData" [])
                                ]
                            |)
                          ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "move_core_types::transaction_argument::TransactionArgument::Bool",
                          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 "bool" ]
                          |),
                          [
                            M.read (| __serializer |);
                            M.read (| Value.String "TransactionArgument" |);
                            Value.Integer IntegerKind.U32 5;
                            M.read (| Value.String "Bool" |);
                            M.read (| __field0 |)
                          ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "move_core_types::transaction_argument::TransactionArgument::U16",
                          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 "TransactionArgument" |);
                            Value.Integer IntegerKind.U32 6;
                            M.read (| Value.String "U16" |);
                            M.read (| __field0 |)
                          ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "move_core_types::transaction_argument::TransactionArgument::U32",
                          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 "TransactionArgument" |);
                            Value.Integer IntegerKind.U32 7;
                            M.read (| Value.String "U32" |);
                            M.read (| __field0 |)
                          ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "move_core_types::transaction_argument::TransactionArgument::U256",
                          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 "TransactionArgument" |);
                            Value.Integer IntegerKind.U32 8;
                            M.read (| Value.String "U256" |);
                            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_core_types_transaction_argument_TransactionArgument.
    Module Impl_serde_de_Deserialize_for_move_core_types_transaction_argument_TransactionArgument.
      Definition Self : Ty.t :=
        Ty.path "move_core_types::transaction_argument::TransactionArgument".
      
      (* 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_core_types::transaction_argument::_'1::deserialize::__Visitor" ]
              |),
              [
                M.read (| __deserializer |);
                M.read (| Value.String "TransactionArgument" |);
                M.read (|
                  M.get_constant (|
                    "move_core_types::transaction_argument::_'1::deserialize::VARIANTS"
                  |)
                |);
                Value.StructRecord
                  "move_core_types::transaction_argument::_'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_core_types_transaction_argument_TransactionArgument.
    Module Impl_serde_de_Deserialize_for_move_core_types_transaction_argument_VecBytes.
      Definition Self : Ty.t := Ty.path "move_core_types::transaction_argument::VecBytes".
      
      (* 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_newtype_struct",
                [ Ty.path "move_core_types::transaction_argument::_'2::deserialize::__Visitor" ]
              |),
              [
                M.read (| __deserializer |);
                M.read (| Value.String "VecBytes" |);
                Value.StructRecord
                  "move_core_types::transaction_argument::_'2::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_core_types_transaction_argument_VecBytes.
  End underscore.
  
  
  Module Impl_core_fmt_Debug_for_move_core_types_transaction_argument_TransactionArgument.
    Definition Self : Ty.t := Ty.path "move_core_types::transaction_argument::TransactionArgument".
    
    (*
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            match self {
                TransactionArgument::U8(value) => write!(f, "{{U8: {}}}", value),
                TransactionArgument::U64(value) => write!(f, "{{U64: {}}}", value),
                TransactionArgument::U128(value) => write!(f, "{{U128: {}}}", value),
                TransactionArgument::Bool(boolean) => write!(f, "{{BOOL: {}}}", boolean),
                TransactionArgument::Address(address) => write!(f, "{{ADDRESS: {:?}}}", address),
                TransactionArgument::U8Vector(vector) => {
                    write!(f, "{{U8Vector: 0x{}}}", hex::encode(vector))
                }
                TransactionArgument::U16(value) => write!(f, "{{U16: {}}}", value),
                TransactionArgument::U32(value) => write!(f, "{{U32: {}}}", value),
                TransactionArgument::U256(value) => write!(f, "{{U256: {}}}", value),
            }
        }
    *)
    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 γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U8",
                        0
                      |) in
                    let value := 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 "{U8: " |); 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 "u8" ] ]
                                      |),
                                      [ value ]
                                    |)
                                  ]
                              |)
                            ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U64",
                        0
                      |) in
                    let value := 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 "{U64: " |);
                                    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 "u64" ] ]
                                      |),
                                      [ value ]
                                    |)
                                  ]
                              |)
                            ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U128",
                        0
                      |) in
                    let value := 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 "{U128: " |);
                                    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 "u128" ] ]
                                      |),
                                      [ value ]
                                    |)
                                  ]
                              |)
                            ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::Bool",
                        0
                      |) in
                    let boolean := 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 "{BOOL: " |);
                                    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 "bool" ] ]
                                      |),
                                      [ boolean ]
                                    |)
                                  ]
                              |)
                            ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::Address",
                        0
                      |) in
                    let address := 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 "{ADDRESS: " |);
                                    M.read (| Value.String "}" |)
                                  ]
                              |);
                              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
                                                "move_core_types::account_address::AccountAddress"
                                            ]
                                        ]
                                      |),
                                      [ address ]
                                    |)
                                  ]
                              |)
                            ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U8Vector",
                        0
                      |) in
                    let vector := 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 "{U8Vector: 0x" |);
                                    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_function (|
                                              "hex::encode",
                                              [
                                                Ty.apply
                                                  (Ty.path "&")
                                                  []
                                                  [
                                                    Ty.apply
                                                      (Ty.path "alloc::vec::Vec")
                                                      []
                                                      [ Ty.path "u8"; Ty.path "alloc::alloc::Global"
                                                      ]
                                                  ]
                                              ]
                                            |),
                                            [ M.read (| vector |) ]
                                          |)
                                        |)
                                      ]
                                    |)
                                  ]
                              |)
                            ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U16",
                        0
                      |) in
                    let value := 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 "{U16: " |);
                                    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 "u16" ] ]
                                      |),
                                      [ value ]
                                    |)
                                  ]
                              |)
                            ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U32",
                        0
                      |) in
                    let value := 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 "{U32: " |);
                                    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 "u32" ] ]
                                      |),
                                      [ value ]
                                    |)
                                  ]
                              |)
                            ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ := M.read (| γ |) in
                    let γ1_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U256",
                        0
                      |) in
                    let value := 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 "{U256: " |);
                                    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_core_types::u256::U256" ]
                                        ]
                                      |),
                                      [ value ]
                                    |)
                                  ]
                              |)
                            ]
                          |)
                        ]
                      |)
                    |)))
              ]
            |)
          |)))
      | _, _, _ => 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_core_types_transaction_argument_TransactionArgument.
  
  Module Impl_core_convert_From_move_core_types_transaction_argument_TransactionArgument_for_move_core_types_runtime_value_MoveValue.
    Definition Self : Ty.t := Ty.path "move_core_types::runtime_value::MoveValue".
    
    (*
        fn from(val: TransactionArgument) -> Self {
            match val {
                TransactionArgument::U8(i) => MoveValue::U8(i),
                TransactionArgument::U64(i) => MoveValue::U64(i),
                TransactionArgument::U128(i) => MoveValue::U128(i),
                TransactionArgument::Address(a) => MoveValue::Address(a),
                TransactionArgument::Bool(b) => MoveValue::Bool(b),
                TransactionArgument::U8Vector(v) => MoveValue::vector_u8(v),
                TransactionArgument::U16(i) => MoveValue::U16(i),
                TransactionArgument::U32(i) => MoveValue::U32(i),
                TransactionArgument::U256(i) => MoveValue::U256(i),
            }
        }
    *)
    Definition from (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ val ] =>
        ltac:(M.monadic
          (let val := M.alloc (| val |) in
          M.read (|
            M.match_operator (|
              val,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U8",
                        0
                      |) in
                    let i := M.copy (| γ0_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_core_types::runtime_value::MoveValue::U8"
                        [ M.read (| i |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U64",
                        0
                      |) in
                    let i := M.copy (| γ0_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_core_types::runtime_value::MoveValue::U64"
                        [ M.read (| i |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U128",
                        0
                      |) in
                    let i := M.copy (| γ0_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_core_types::runtime_value::MoveValue::U128"
                        [ M.read (| i |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::Address",
                        0
                      |) in
                    let a := M.copy (| γ0_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_core_types::runtime_value::MoveValue::Address"
                        [ M.read (| a |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::Bool",
                        0
                      |) in
                    let b := M.copy (| γ0_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_core_types::runtime_value::MoveValue::Bool"
                        [ M.read (| b |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U8Vector",
                        0
                      |) in
                    let v := M.copy (| γ0_0 |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "move_core_types::runtime_value::MoveValue",
                          "vector_u8",
                          []
                        |),
                        [ M.read (| v |) ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U16",
                        0
                      |) in
                    let i := M.copy (| γ0_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_core_types::runtime_value::MoveValue::U16"
                        [ M.read (| i |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U32",
                        0
                      |) in
                    let i := M.copy (| γ0_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_core_types::runtime_value::MoveValue::U32"
                        [ M.read (| i |) ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "move_core_types::transaction_argument::TransactionArgument::U256",
                        0
                      |) in
                    let i := M.copy (| γ0_0 |) in
                    M.alloc (|
                      Value.StructTuple
                        "move_core_types::runtime_value::MoveValue::U256"
                        [ M.read (| i |) ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::convert::From"
        Self
        (* Trait polymorphic types *)
        [ (* T *) Ty.path "move_core_types::transaction_argument::TransactionArgument" ]
        (* Instance *) [ ("from", InstanceField.Method from) ].
  End Impl_core_convert_From_move_core_types_transaction_argument_TransactionArgument_for_move_core_types_runtime_value_MoveValue.
  
  Module Impl_core_convert_TryFrom_move_core_types_runtime_value_MoveValue_for_move_core_types_transaction_argument_TransactionArgument.
    Definition Self : Ty.t := Ty.path "move_core_types::transaction_argument::TransactionArgument".
    
    (*     type Error = Error; *)
    Definition _Error : Ty.t := Ty.path "anyhow::Error".
    
    (*
        fn try_from(val: MoveValue) -> Result<Self> {
            Ok(match val {
                MoveValue::U8(i) => TransactionArgument::U8(i),
                MoveValue::U64(i) => TransactionArgument::U64(i),
                MoveValue::U128(i) => TransactionArgument::U128(i),
                MoveValue::Address(a) => TransactionArgument::Address(a),
                MoveValue::Bool(b) => TransactionArgument::Bool(b),
                MoveValue::Vector(v) => TransactionArgument::U8Vector(
                    v.into_iter()
                        .map(|mv| {
                            if let MoveValue::U8(byte) = mv {
                                Ok(byte)
                            } else {
                                Err(anyhow!("unexpected value in bytes: {:?}", mv))
                            }
                        })
                        .collect::<Result<Vec<u8>>>()?,
                ),
                MoveValue::Signer(_) | MoveValue::Struct(_) => {
                    return Err(anyhow!("invalid transaction argument: {:?}", val))
                }
                MoveValue::U16(i) => TransactionArgument::U16(i),
                MoveValue::U32(i) => TransactionArgument::U32(i),
                MoveValue::U256(i) => TransactionArgument::U256(i),
            })
        }
    *)
    Definition try_from (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ val ] =>
        ltac:(M.monadic
          (let val := M.alloc (| val |) in
          M.catch_return (|
            ltac:(M.monadic
              (Value.StructTuple
                "core::result::Result::Ok"
                [
                  M.read (|
                    M.match_operator (|
                      val,
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "move_core_types::runtime_value::MoveValue::U8",
                                0
                              |) in
                            let i := M.copy (| γ0_0 |) in
                            M.alloc (|
                              Value.StructTuple
                                "move_core_types::transaction_argument::TransactionArgument::U8"
                                [ M.read (| i |) ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "move_core_types::runtime_value::MoveValue::U64",
                                0
                              |) in
                            let i := M.copy (| γ0_0 |) in
                            M.alloc (|
                              Value.StructTuple
                                "move_core_types::transaction_argument::TransactionArgument::U64"
                                [ M.read (| i |) ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "move_core_types::runtime_value::MoveValue::U128",
                                0
                              |) in
                            let i := M.copy (| γ0_0 |) in
                            M.alloc (|
                              Value.StructTuple
                                "move_core_types::transaction_argument::TransactionArgument::U128"
                                [ M.read (| i |) ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "move_core_types::runtime_value::MoveValue::Address",
                                0
                              |) in
                            let a := M.copy (| γ0_0 |) in
                            M.alloc (|
                              Value.StructTuple
                                "move_core_types::transaction_argument::TransactionArgument::Address"
                                [ M.read (| a |) ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "move_core_types::runtime_value::MoveValue::Bool",
                                0
                              |) in
                            let b := M.copy (| γ0_0 |) in
                            M.alloc (|
                              Value.StructTuple
                                "move_core_types::transaction_argument::TransactionArgument::Bool"
                                [ M.read (| b |) ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "move_core_types::runtime_value::MoveValue::Vector",
                                0
                              |) in
                            let v := M.copy (| γ0_0 |) in
                            M.alloc (|
                              Value.StructTuple
                                "move_core_types::transaction_argument::TransactionArgument::U8Vector"
                                [
                                  M.read (|
                                    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.apply
                                                  (Ty.path "alloc::vec::Vec")
                                                  []
                                                  [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ];
                                                Ty.path "anyhow::Error"
                                              ],
                                            [],
                                            "branch",
                                            []
                                          |),
                                          [
                                            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::runtime_value::MoveValue";
                                                        Ty.path "alloc::alloc::Global"
                                                      ];
                                                    Ty.function
                                                      [
                                                        Ty.tuple
                                                          [
                                                            Ty.path
                                                              "move_core_types::runtime_value::MoveValue"
                                                          ]
                                                      ]
                                                      (Ty.apply
                                                        (Ty.path "core::result::Result")
                                                        []
                                                        [ Ty.path "u8"; Ty.path "anyhow::Error" ])
                                                  ],
                                                [],
                                                "collect",
                                                [
                                                  Ty.apply
                                                    (Ty.path "core::result::Result")
                                                    []
                                                    [
                                                      Ty.apply
                                                        (Ty.path "alloc::vec::Vec")
                                                        []
                                                        [
                                                          Ty.path "u8";
                                                          Ty.path "alloc::alloc::Global"
                                                        ];
                                                      Ty.path "anyhow::Error"
                                                    ]
                                                ]
                                              |),
                                              [
                                                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::runtime_value::MoveValue";
                                                        Ty.path "alloc::alloc::Global"
                                                      ],
                                                    [],
                                                    "map",
                                                    [
                                                      Ty.apply
                                                        (Ty.path "core::result::Result")
                                                        []
                                                        [ Ty.path "u8"; Ty.path "anyhow::Error" ];
                                                      Ty.function
                                                        [
                                                          Ty.tuple
                                                            [
                                                              Ty.path
                                                                "move_core_types::runtime_value::MoveValue"
                                                            ]
                                                        ]
                                                        (Ty.apply
                                                          (Ty.path "core::result::Result")
                                                          []
                                                          [ Ty.path "u8"; Ty.path "anyhow::Error" ])
                                                    ]
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_trait_method (|
                                                        "core::iter::traits::collect::IntoIterator",
                                                        Ty.apply
                                                          (Ty.path "alloc::vec::Vec")
                                                          []
                                                          [
                                                            Ty.path
                                                              "move_core_types::runtime_value::MoveValue";
                                                            Ty.path "alloc::alloc::Global"
                                                          ],
                                                        [],
                                                        "into_iter",
                                                        []
                                                      |),
                                                      [ M.read (| v |) ]
                                                    |);
                                                    M.closure
                                                      (fun γ =>
                                                        ltac:(M.monadic
                                                          match γ with
                                                          | [ α0 ] =>
                                                            ltac:(M.monadic
                                                              (M.match_operator (|
                                                                M.alloc (| α0 |),
                                                                [
                                                                  fun γ =>
                                                                    ltac:(M.monadic
                                                                      (let mv := M.copy (| γ |) in
                                                                      M.read (|
                                                                        M.match_operator (|
                                                                          M.alloc (|
                                                                            Value.Tuple []
                                                                          |),
                                                                          [
                                                                            fun γ =>
                                                                              ltac:(M.monadic
                                                                                (let γ := mv in
                                                                                let γ0_0 :=
                                                                                  M.SubPointer.get_struct_tuple_field (|
                                                                                    γ,
                                                                                    "move_core_types::runtime_value::MoveValue::U8",
                                                                                    0
                                                                                  |) in
                                                                                let byte :=
                                                                                  M.copy (|
                                                                                    γ0_0
                                                                                  |) in
                                                                                M.alloc (|
                                                                                  Value.StructTuple
                                                                                    "core::result::Result::Ok"
                                                                                    [
                                                                                      M.read (|
                                                                                        byte
                                                                                      |)
                                                                                    ]
                                                                                |)));
                                                                            fun γ =>
                                                                              ltac:(M.monadic
                                                                                (M.alloc (|
                                                                                  Value.StructTuple
                                                                                    "core::result::Result::Err"
                                                                                    [
                                                                                      M.call_closure (|
                                                                                        M.get_associated_function (|
                                                                                          Ty.path
                                                                                            "anyhow::Error",
                                                                                          "msg",
                                                                                          [
                                                                                            Ty.path
                                                                                              "alloc::string::String"
                                                                                          ]
                                                                                        |),
                                                                                        [
                                                                                          M.call_closure (|
                                                                                            M.get_function (|
                                                                                              "core::hint::must_use",
                                                                                              [
                                                                                                Ty.path
                                                                                                  "alloc::string::String"
                                                                                              ]
                                                                                            |),
                                                                                            [
                                                                                              M.read (|
                                                                                                let~
                                                                                                      res :=
                                                                                                  M.alloc (|
                                                                                                    M.call_closure (|
                                                                                                      M.get_function (|
                                                                                                        "alloc::fmt::format",
                                                                                                        []
                                                                                                      |),
                                                                                                      [
                                                                                                        M.call_closure (|
                                                                                                          M.get_associated_function (|
                                                                                                            Ty.path
                                                                                                              "core::fmt::Arguments",
                                                                                                            "new_v1",
                                                                                                            []
                                                                                                          |),
                                                                                                          [
                                                                                                            M.alloc (|
                                                                                                              Value.Array
                                                                                                                [
                                                                                                                  M.read (|
                                                                                                                    Value.String
                                                                                                                      "unexpected value in bytes: "
                                                                                                                  |)
                                                                                                                ]
                                                                                                            |);
                                                                                                            M.alloc (|
                                                                                                              Value.Array
                                                                                                                [
                                                                                                                  M.call_closure (|
                                                                                                                    M.get_associated_function (|
                                                                                                                      Ty.path
                                                                                                                        "core::fmt::rt::Argument",
                                                                                                                      "new_debug",
                                                                                                                      [
                                                                                                                        Ty.path
                                                                                                                          "move_core_types::runtime_value::MoveValue"
                                                                                                                      ]
                                                                                                                    |),
                                                                                                                    [
                                                                                                                      mv
                                                                                                                    ]
                                                                                                                  |)
                                                                                                                ]
                                                                                                            |)
                                                                                                          ]
                                                                                                        |)
                                                                                                      ]
                                                                                                    |)
                                                                                                  |) in
                                                                                                res
                                                                                              |)
                                                                                            ]
                                                                                          |)
                                                                                        ]
                                                                                      |)
                                                                                    ]
                                                                                |)))
                                                                          ]
                                                                        |)
                                                                      |)))
                                                                ]
                                                              |)))
                                                          | _ =>
                                                            M.impossible "wrong number of arguments"
                                                          end))
                                                  ]
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |),
                                      [
                                        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.path
                                                              "move_core_types::transaction_argument::TransactionArgument";
                                                            Ty.path "anyhow::Error"
                                                          ],
                                                        [
                                                          Ty.apply
                                                            (Ty.path "core::result::Result")
                                                            []
                                                            [
                                                              Ty.path "core::convert::Infallible";
                                                              Ty.path "anyhow::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))
                                      ]
                                    |)
                                  |)
                                ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (M.find_or_pattern (|
                              γ,
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "move_core_types::runtime_value::MoveValue::Signer",
                                        0
                                      |) in
                                    Value.Tuple []));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "move_core_types::runtime_value::MoveValue::Struct",
                                        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::result::Result::Err"
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "anyhow::Error",
                                                        "msg",
                                                        [ Ty.path "alloc::string::String" ]
                                                      |),
                                                      [
                                                        M.call_closure (|
                                                          M.get_function (|
                                                            "core::hint::must_use",
                                                            [ Ty.path "alloc::string::String" ]
                                                          |),
                                                          [
                                                            M.read (|
                                                              let~ res :=
                                                                M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_function (|
                                                                      "alloc::fmt::format",
                                                                      []
                                                                    |),
                                                                    [
                                                                      M.call_closure (|
                                                                        M.get_associated_function (|
                                                                          Ty.path
                                                                            "core::fmt::Arguments",
                                                                          "new_v1",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.read (|
                                                                                  Value.String
                                                                                    "invalid transaction argument: "
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Argument",
                                                                                    "new_debug",
                                                                                    [
                                                                                      Ty.path
                                                                                        "move_core_types::runtime_value::MoveValue"
                                                                                    ]
                                                                                  |),
                                                                                  [ val ]
                                                                                |)
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |) in
                                                              res
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                              |)
                                            |)
                                          |)
                                        |)))
                                    | _ => M.impossible "wrong number of arguments"
                                    end))
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "move_core_types::runtime_value::MoveValue::U16",
                                0
                              |) in
                            let i := M.copy (| γ0_0 |) in
                            M.alloc (|
                              Value.StructTuple
                                "move_core_types::transaction_argument::TransactionArgument::U16"
                                [ M.read (| i |) ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "move_core_types::runtime_value::MoveValue::U32",
                                0
                              |) in
                            let i := M.copy (| γ0_0 |) in
                            M.alloc (|
                              Value.StructTuple
                                "move_core_types::transaction_argument::TransactionArgument::U32"
                                [ M.read (| i |) ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "move_core_types::runtime_value::MoveValue::U256",
                                0
                              |) in
                            let i := M.copy (| γ0_0 |) in
                            M.alloc (|
                              Value.StructTuple
                                "move_core_types::transaction_argument::TransactionArgument::U256"
                                [ M.read (| i |) ]
                            |)))
                      ]
                    |)
                  |)
                ]))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::convert::TryFrom"
        Self
        (* Trait polymorphic types *)
        [ (* T *) Ty.path "move_core_types::runtime_value::MoveValue" ]
        (* Instance *)
        [ ("Error", InstanceField.Ty _Error); ("try_from", InstanceField.Method try_from) ].
  End Impl_core_convert_TryFrom_move_core_types_runtime_value_MoveValue_for_move_core_types_transaction_argument_TransactionArgument.
  
  (*
  pub fn convert_txn_args(args: &[TransactionArgument]) -> Vec<Vec<u8>> {
      args.iter()
          .map(|arg| {
              MoveValue::from(arg.clone())
                  .simple_serialize()
                  .expect("transaction arguments must serialize")
          })
          .collect()
  }
  *)
  Definition convert_txn_args (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [], [ args ] =>
      ltac:(M.monadic
        (let args := M.alloc (| args |) 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_core_types::transaction_argument::TransactionArgument" ];
                Ty.function
                  [
                    Ty.tuple
                      [
                        Ty.apply
                          (Ty.path "&")
                          []
                          [ Ty.path "move_core_types::transaction_argument::TransactionArgument" ]
                      ]
                  ]
                  (Ty.apply
                    (Ty.path "alloc::vec::Vec")
                    []
                    [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ])
              ],
            [],
            "collect",
            [
              Ty.apply
                (Ty.path "alloc::vec::Vec")
                []
                [
                  Ty.apply
                    (Ty.path "alloc::vec::Vec")
                    []
                    [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ];
                  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_core_types::transaction_argument::TransactionArgument" ],
                [],
                "map",
                [
                  Ty.apply
                    (Ty.path "alloc::vec::Vec")
                    []
                    [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ];
                  Ty.function
                    [
                      Ty.tuple
                        [
                          Ty.apply
                            (Ty.path "&")
                            []
                            [ Ty.path "move_core_types::transaction_argument::TransactionArgument" ]
                        ]
                    ]
                    (Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ])
                ]
              |),
              [
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.apply
                      (Ty.path "slice")
                      []
                      [ Ty.path "move_core_types::transaction_argument::TransactionArgument" ],
                    "iter",
                    []
                  |),
                  [ M.read (| args |) ]
                |);
                M.closure
                  (fun γ =>
                    ltac:(M.monadic
                      match γ with
                      | [ α0 ] =>
                        ltac:(M.monadic
                          (M.match_operator (|
                            M.alloc (| α0 |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let arg := M.copy (| γ |) in
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ]
                                        ],
                                      "expect",
                                      []
                                    |),
                                    [
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.path "move_core_types::runtime_value::MoveValue",
                                          "simple_serialize",
                                          []
                                        |),
                                        [
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_trait_method (|
                                                "core::convert::From",
                                                Ty.path "move_core_types::runtime_value::MoveValue",
                                                [
                                                  Ty.path
                                                    "move_core_types::transaction_argument::TransactionArgument"
                                                ],
                                                "from",
                                                []
                                              |),
                                              [
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::clone::Clone",
                                                    Ty.path
                                                      "move_core_types::transaction_argument::TransactionArgument",
                                                    [],
                                                    "clone",
                                                    []
                                                  |),
                                                  [ M.read (| arg |) ]
                                                |)
                                              ]
                                            |)
                                          |)
                                        ]
                                      |);
                                      M.read (|
                                        Value.String "transaction arguments must serialize"
                                      |)
                                    ]
                                  |)))
                            ]
                          |)))
                      | _ => M.impossible "wrong number of arguments"
                      end))
              ]
            |)
          ]
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_convert_txn_args :
    M.IsFunction "move_core_types::transaction_argument::convert_txn_args" convert_txn_args.
  
  (* StructTuple
    {
      name := "VecBytes";
      const_params := [];
      ty_params := [];
      fields :=
        [
          Ty.apply
            (Ty.path "alloc::vec::Vec")
            []
            [ Ty.path "serde_bytes::bytebuf::ByteBuf"; Ty.path "alloc::alloc::Global" ]
        ];
    } *)
  
  Module Impl_core_clone_Clone_for_move_core_types_transaction_argument_VecBytes.
    Definition Self : Ty.t := Ty.path "move_core_types::transaction_argument::VecBytes".
    
    (* Clone *)
    Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          Value.StructTuple
            "move_core_types::transaction_argument::VecBytes"
            [
              M.call_closure (|
                M.get_trait_method (|
                  "core::clone::Clone",
                  Ty.apply
                    (Ty.path "alloc::vec::Vec")
                    []
                    [ Ty.path "serde_bytes::bytebuf::ByteBuf"; Ty.path "alloc::alloc::Global" ],
                  [],
                  "clone",
                  []
                |),
                [
                  M.SubPointer.get_struct_tuple_field (|
                    M.read (| self |),
                    "move_core_types::transaction_argument::VecBytes",
                    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_core_types_transaction_argument_VecBytes.
  
  Module Impl_core_hash_Hash_for_move_core_types_transaction_argument_VecBytes.
    Definition Self : Ty.t := Ty.path "move_core_types::transaction_argument::VecBytes".
    
    (* Hash *)
    Definition hash (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [ __H ], [ self; state ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let state := M.alloc (| state |) in
          M.call_closure (|
            M.get_trait_method (|
              "core::hash::Hash",
              Ty.apply
                (Ty.path "alloc::vec::Vec")
                []
                [ Ty.path "serde_bytes::bytebuf::ByteBuf"; Ty.path "alloc::alloc::Global" ],
              [],
              "hash",
              [ __H ]
            |),
            [
              M.SubPointer.get_struct_tuple_field (|
                M.read (| self |),
                "move_core_types::transaction_argument::VecBytes",
                0
              |);
              M.read (| state |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::hash::Hash"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [ ("hash", InstanceField.Method hash) ].
  End Impl_core_hash_Hash_for_move_core_types_transaction_argument_VecBytes.
  
  Module Impl_core_cmp_Eq_for_move_core_types_transaction_argument_VecBytes.
    Definition Self : Ty.t := Ty.path "move_core_types::transaction_argument::VecBytes".
    
    (* Eq *)
    Definition assert_receiver_is_total_eq
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.read (|
            M.match_operator (|
              Value.DeclaredButUndefined,
              [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "core::cmp::Eq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *)
        [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ].
  End Impl_core_cmp_Eq_for_move_core_types_transaction_argument_VecBytes.
  
  Module Impl_core_marker_StructuralPartialEq_for_move_core_types_transaction_argument_VecBytes.
    Definition Self : Ty.t := Ty.path "move_core_types::transaction_argument::VecBytes".
    
    Axiom Implements :
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_move_core_types_transaction_argument_VecBytes.
  
  Module Impl_core_cmp_PartialEq_for_move_core_types_transaction_argument_VecBytes.
    Definition Self : Ty.t := Ty.path "move_core_types::transaction_argument::VecBytes".
    
    (* PartialEq *)
    Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.call_closure (|
            M.get_trait_method (|
              "core::cmp::PartialEq",
              Ty.apply
                (Ty.path "alloc::vec::Vec")
                []
                [ Ty.path "serde_bytes::bytebuf::ByteBuf"; Ty.path "alloc::alloc::Global" ],
              [
                Ty.apply
                  (Ty.path "alloc::vec::Vec")
                  []
                  [ Ty.path "serde_bytes::bytebuf::ByteBuf"; Ty.path "alloc::alloc::Global" ]
              ],
              "eq",
              []
            |),
            [
              M.SubPointer.get_struct_tuple_field (|
                M.read (| self |),
                "move_core_types::transaction_argument::VecBytes",
                0
              |);
              M.SubPointer.get_struct_tuple_field (|
                M.read (| other |),
                "move_core_types::transaction_argument::VecBytes",
                0
              |)
            ]
          |)))
      | _, _, _ => 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_core_types_transaction_argument_VecBytes.
  
  
  Module Impl_move_core_types_transaction_argument_VecBytes.
    Definition Self : Ty.t := Ty.path "move_core_types::transaction_argument::VecBytes".
    
    (*
        pub fn from(vec_bytes: Vec<Vec<u8>>) -> Self {
            VecBytes(
                vec_bytes
                    .into_iter()
                    .map(serde_bytes::ByteBuf::from)
                    .collect(),
            )
        }
    *)
    Definition from (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ vec_bytes ] =>
        ltac:(M.monadic
          (let vec_bytes := M.alloc (| vec_bytes |) in
          Value.StructTuple
            "move_core_types::transaction_argument::VecBytes"
            [
              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.apply
                            (Ty.path "alloc::vec::Vec")
                            []
                            [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ];
                          Ty.path "alloc::alloc::Global"
                        ];
                      Ty.function
                        [
                          Ty.apply
                            (Ty.path "alloc::vec::Vec")
                            []
                            [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ]
                        ]
                        (Ty.path "serde_bytes::bytebuf::ByteBuf")
                    ],
                  [],
                  "collect",
                  [
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [ Ty.path "serde_bytes::bytebuf::ByteBuf"; 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.apply
                            (Ty.path "alloc::vec::Vec")
                            []
                            [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ];
                          Ty.path "alloc::alloc::Global"
                        ],
                      [],
                      "map",
                      [
                        Ty.path "serde_bytes::bytebuf::ByteBuf";
                        Ty.function
                          [
                            Ty.apply
                              (Ty.path "alloc::vec::Vec")
                              []
                              [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ]
                          ]
                          (Ty.path "serde_bytes::bytebuf::ByteBuf")
                      ]
                    |),
                    [
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::iter::traits::collect::IntoIterator",
                          Ty.apply
                            (Ty.path "alloc::vec::Vec")
                            []
                            [
                              Ty.apply
                                (Ty.path "alloc::vec::Vec")
                                []
                                [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ];
                              Ty.path "alloc::alloc::Global"
                            ],
                          [],
                          "into_iter",
                          []
                        |),
                        [ M.read (| vec_bytes |) ]
                      |);
                      M.get_associated_function (|
                        Ty.path "serde_bytes::bytebuf::ByteBuf",
                        "from",
                        [
                          Ty.apply
                            (Ty.path "alloc::vec::Vec")
                            []
                            [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ]
                        ]
                      |)
                    ]
                  |)
                ]
              |)
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_from : M.IsAssociatedFunction Self "from" from.
    
    (*
        pub fn into_vec(self) -> Vec<Vec<u8>> {
            self.0
                .into_iter()
                .map(|byte_buf| byte_buf.into_vec())
                .collect()
        }
    *)
    Definition into_vec (ε : 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::iter::adapters::map::Map")
                []
                [
                  Ty.apply
                    (Ty.path "alloc::vec::into_iter::IntoIter")
                    []
                    [ Ty.path "serde_bytes::bytebuf::ByteBuf"; Ty.path "alloc::alloc::Global" ];
                  Ty.function
                    [ Ty.tuple [ Ty.path "serde_bytes::bytebuf::ByteBuf" ] ]
                    (Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ])
                ],
              [],
              "collect",
              [
                Ty.apply
                  (Ty.path "alloc::vec::Vec")
                  []
                  [
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ];
                    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 "serde_bytes::bytebuf::ByteBuf"; Ty.path "alloc::alloc::Global" ],
                  [],
                  "map",
                  [
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ];
                    Ty.function
                      [ Ty.tuple [ Ty.path "serde_bytes::bytebuf::ByteBuf" ] ]
                      (Ty.apply
                        (Ty.path "alloc::vec::Vec")
                        []
                        [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ])
                  ]
                |),
                [
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::iter::traits::collect::IntoIterator",
                      Ty.apply
                        (Ty.path "alloc::vec::Vec")
                        []
                        [ Ty.path "serde_bytes::bytebuf::ByteBuf"; Ty.path "alloc::alloc::Global" ],
                      [],
                      "into_iter",
                      []
                    |),
                    [
                      M.read (|
                        M.SubPointer.get_struct_tuple_field (|
                          self,
                          "move_core_types::transaction_argument::VecBytes",
                          0
                        |)
                      |)
                    ]
                  |);
                  M.closure
                    (fun γ =>
                      ltac:(M.monadic
                        match γ with
                        | [ α0 ] =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              M.alloc (| α0 |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let byte_buf := M.copy (| γ |) in
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path "serde_bytes::bytebuf::ByteBuf",
                                        "into_vec",
                                        []
                                      |),
                                      [ M.read (| byte_buf |) ]
                                    |)))
                              ]
                            |)))
                        | _ => M.impossible "wrong number of arguments"
                        end))
                ]
              |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_into_vec : M.IsAssociatedFunction Self "into_vec" into_vec.
  End Impl_move_core_types_transaction_argument_VecBytes.
End transaction_argument.
