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

Module absint.
  (* StructRecord
    {
      name := "FunctionContext";
      const_params := [];
      ty_params := [];
      fields :=
        [
          ("index",
            Ty.apply
              (Ty.path "core::option::Option")
              []
              [ Ty.path "move_binary_format::file_format::FunctionDefinitionIndex" ]);
          ("code",
            Ty.apply (Ty.path "&") [] [ Ty.path "move_binary_format::file_format::CodeUnit" ]);
          ("parameters",
            Ty.apply (Ty.path "&") [] [ Ty.path "move_binary_format::file_format::Signature" ]);
          ("return_",
            Ty.apply (Ty.path "&") [] [ Ty.path "move_binary_format::file_format::Signature" ]);
          ("locals",
            Ty.apply (Ty.path "&") [] [ Ty.path "move_binary_format::file_format::Signature" ]);
          ("type_parameters",
            Ty.apply
              (Ty.path "&")
              []
              [
                Ty.apply
                  (Ty.path "slice")
                  []
                  [ Ty.path "move_binary_format::file_format::AbilitySet" ]
              ]);
          ("cfg", Ty.path "move_binary_format::control_flow_graph::VMControlFlowGraph")
        ];
    } *)
  
  (* Trait *)
  (* Empty module 'AbstractDomain' *)
  
  (*
  Enum JoinResult
  {
    const_params := [];
    ty_params := [];
    variants :=
      [
        {
          name := "Changed";
          item := StructTuple [];
          discriminant := None;
        };
        {
          name := "Unchanged";
          item := StructTuple [];
          discriminant := None;
        }
      ];
  }
  *)
  
  Module Impl_core_fmt_Debug_for_move_bytecode_verifier_absint_JoinResult.
    Definition Self : Ty.t := Ty.path "move_bytecode_verifier::absint::JoinResult".
    
    (* Debug *)
    Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; f ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let f := M.alloc (| f |) in
          M.call_closure (|
            M.get_associated_function (| Ty.path "core::fmt::Formatter", "write_str", [] |),
            [
              M.read (| f |);
              M.read (|
                M.match_operator (|
                  self,
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (|
                            γ,
                            "move_bytecode_verifier::absint::JoinResult::Changed"
                          |) in
                        M.alloc (| M.read (| Value.String "Changed" |) |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (|
                            γ,
                            "move_bytecode_verifier::absint::JoinResult::Unchanged"
                          |) in
                        M.alloc (| M.read (| Value.String "Unchanged" |) |)))
                  ]
                |)
              |)
            ]
          |)))
      | _, _, _ => 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_bytecode_verifier_absint_JoinResult.
  
  (* StructRecord
    {
      name := "BlockInvariant";
      const_params := [];
      ty_params := [ "State" ];
      fields := [ ("pre", State) ];
    } *)
  
  Module Impl_core_clone_Clone_where_core_clone_Clone_State_for_move_bytecode_verifier_absint_BlockInvariant_State.
    Definition Self (State : Ty.t) : Ty.t :=
      Ty.apply (Ty.path "move_bytecode_verifier::absint::BlockInvariant") [] [ State ].
    
    (* Clone *)
    Definition clone (State : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self State in
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          Value.StructRecord
            "move_bytecode_verifier::absint::BlockInvariant"
            [
              ("pre",
                M.call_closure (|
                  M.get_trait_method (| "core::clone::Clone", State, [], "clone", [] |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_bytecode_verifier::absint::BlockInvariant",
                      "pre"
                    |)
                  ]
                |))
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (State : Ty.t),
      M.IsTraitInstance
        "core::clone::Clone"
        (Self State)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("clone", InstanceField.Method (clone State)) ].
  End Impl_core_clone_Clone_where_core_clone_Clone_State_for_move_bytecode_verifier_absint_BlockInvariant_State.
  
  Axiom InvariantMap :
    forall (State : Ty.t),
    (Ty.apply (Ty.path "move_bytecode_verifier::absint::InvariantMap") [] [ State ]) =
      (Ty.apply
        (Ty.path "alloc::collections::btree::map::BTreeMap")
        []
        [
          Ty.path "u16";
          Ty.apply (Ty.path "move_bytecode_verifier::absint::BlockInvariant") [] [ State ];
          Ty.path "alloc::alloc::Global"
        ]).
  
  Definition value_ANALYZE_FUNCTION_BASE_COST : Value.t :=
    M.run ltac:(M.monadic (M.alloc (| Value.Integer IntegerKind.U128 10 |))).
  
  Definition value_EXECUTE_BLOCK_BASE_COST : Value.t :=
    M.run ltac:(M.monadic (M.alloc (| Value.Integer IntegerKind.U128 10 |))).
  
  Definition value_PER_BACKEDGE_COST : Value.t :=
    M.run ltac:(M.monadic (M.alloc (| Value.Integer IntegerKind.U128 10 |))).
  
  Definition value_PER_SUCCESSOR_COST : Value.t :=
    M.run ltac:(M.monadic (M.alloc (| Value.Integer IntegerKind.U128 10 |))).
  
  (* Trait *)
  (* Empty module 'TransferFunctions' *)
  
  (* Trait *)
  Module AbstractInterpreter.
    Definition analyze_function
        (Self : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      match ε, τ, α with
      | [], [ impl_Meter__plus___Sized ], [ self; initial_state; function_context; meter ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let initial_state := M.alloc (| initial_state |) in
          let function_context := M.alloc (| function_context |) in
          let meter := M.alloc (| meter |) in
          M.catch_return (|
            ltac:(M.monadic
              (M.read (|
                let~ _ :=
                  M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::ops::try_trait::Try",
                          Ty.apply
                            (Ty.path "core::result::Result")
                            []
                            [ Ty.tuple []; Ty.path "move_binary_format::errors::PartialVMError" ],
                          [],
                          "branch",
                          []
                        |),
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "move_bytecode_verifier_meter::Meter",
                              impl_Meter__plus___Sized,
                              [],
                              "add",
                              []
                            |),
                            [
                              M.read (| meter |);
                              Value.StructTuple "move_bytecode_verifier_meter::Scope::Function" [];
                              M.read (|
                                M.get_constant (|
                                  "move_bytecode_verifier::absint::ANALYZE_FUNCTION_BASE_COST"
                                |)
                              |)
                            ]
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::ops::control_flow::ControlFlow::Break",
                              0
                            |) in
                          let residual := M.copy (| γ0_0 |) in
                          M.alloc (|
                            M.never_to_any (|
                              M.read (|
                                M.return_ (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::ops::try_trait::FromResidual",
                                      Ty.apply
                                        (Ty.path "core::result::Result")
                                        []
                                        [
                                          Ty.tuple [];
                                          Ty.path "move_binary_format::errors::PartialVMError"
                                        ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::result::Result")
                                          []
                                          [
                                            Ty.path "core::convert::Infallible";
                                            Ty.path "move_binary_format::errors::PartialVMError"
                                          ]
                                      ],
                                      "from_residual",
                                      []
                                    |),
                                    [ M.read (| residual |) ]
                                  |)
                                |)
                              |)
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::ops::control_flow::ControlFlow::Continue",
                              0
                            |) in
                          let val := M.copy (| γ0_0 |) in
                          val))
                    ]
                  |) in
                let~ inv_map :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_associated_function (|
                        Ty.apply
                          (Ty.path "alloc::collections::btree::map::BTreeMap")
                          []
                          [
                            Ty.path "u16";
                            Ty.apply
                              (Ty.path "move_bytecode_verifier::absint::BlockInvariant")
                              []
                              [ Ty.associated ];
                            Ty.path "alloc::alloc::Global"
                          ],
                        "new",
                        []
                      |),
                      []
                    |)
                  |) in
                let~ entry_block_id :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "move_binary_format::control_flow_graph::ControlFlowGraph",
                        Ty.path "move_binary_format::control_flow_graph::VMControlFlowGraph",
                        [],
                        "entry_block_id",
                        []
                      |),
                      [
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "move_bytecode_verifier::absint::FunctionContext",
                            "cfg",
                            []
                          |),
                          [ M.read (| function_context |) ]
                        |)
                      ]
                    |)
                  |) in
                let~ next_block :=
                  M.alloc (|
                    Value.StructTuple "core::option::Option::Some" [ M.read (| entry_block_id |) ]
                  |) in
                let~ _ :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_associated_function (|
                        Ty.apply
                          (Ty.path "alloc::collections::btree::map::BTreeMap")
                          []
                          [
                            Ty.path "u16";
                            Ty.apply
                              (Ty.path "move_bytecode_verifier::absint::BlockInvariant")
                              []
                              [ Ty.associated ];
                            Ty.path "alloc::alloc::Global"
                          ],
                        "insert",
                        []
                      |),
                      [
                        inv_map;
                        M.read (| entry_block_id |);
                        Value.StructRecord
                          "move_bytecode_verifier::absint::BlockInvariant"
                          [ ("pre", M.read (| initial_state |)) ]
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.loop (|
                    ltac:(M.monadic
                      (M.match_operator (|
                        M.alloc (| Value.Tuple [] |),
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let γ := next_block in
                              let γ0_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ,
                                  "core::option::Option::Some",
                                  0
                                |) in
                              let block_id := M.copy (| γ0_0 |) in
                              let~ block_invariant :=
                                M.copy (|
                                  M.match_operator (|
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.apply
                                            (Ty.path "alloc::collections::btree::map::BTreeMap")
                                            []
                                            [
                                              Ty.path "u16";
                                              Ty.apply
                                                (Ty.path
                                                  "move_bytecode_verifier::absint::BlockInvariant")
                                                []
                                                [ Ty.associated ];
                                              Ty.path "alloc::alloc::Global"
                                            ],
                                          "get_mut",
                                          [ Ty.path "u16" ]
                                        |),
                                        [ inv_map; block_id ]
                                      |)
                                    |),
                                    [
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let γ0_0 :=
                                            M.SubPointer.get_struct_tuple_field (|
                                              γ,
                                              "core::option::Option::Some",
                                              0
                                            |) in
                                          let invariant := M.copy (| γ0_0 |) in
                                          invariant));
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let _ :=
                                            M.is_struct_tuple (|
                                              γ,
                                              "core::option::Option::None"
                                            |) in
                                          M.alloc (|
                                            M.never_to_any (|
                                              M.read (|
                                                let~ _ :=
                                                  M.write (|
                                                    next_block,
                                                    M.call_closure (|
                                                      M.get_trait_method (|
                                                        "move_binary_format::control_flow_graph::ControlFlowGraph",
                                                        Ty.path
                                                          "move_binary_format::control_flow_graph::VMControlFlowGraph",
                                                        [],
                                                        "next_block",
                                                        []
                                                      |),
                                                      [
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_bytecode_verifier::absint::FunctionContext",
                                                            "cfg",
                                                            []
                                                          |),
                                                          [ M.read (| function_context |) ]
                                                        |);
                                                        M.read (| block_id |)
                                                      ]
                                                    |)
                                                  |) in
                                                M.continue (||)
                                              |)
                                            |)
                                          |)))
                                    ]
                                  |)
                                |) in
                              let~ pre_state :=
                                M.alloc (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| block_invariant |),
                                    "move_bytecode_verifier::absint::BlockInvariant",
                                    "pre"
                                  |)
                                |) in
                              let~ post_state :=
                                M.copy (|
                                  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.associated;
                                              Ty.path "move_binary_format::errors::PartialVMError"
                                            ],
                                          [],
                                          "branch",
                                          []
                                        |),
                                        [
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "move_bytecode_verifier::absint::AbstractInterpreter",
                                              Self,
                                              [],
                                              "execute_block",
                                              [ impl_Meter__plus___Sized ]
                                            |),
                                            [
                                              M.read (| self |);
                                              M.read (| block_id |);
                                              M.read (| pre_state |);
                                              M.read (| function_context |);
                                              M.read (| meter |)
                                            ]
                                          |)
                                        ]
                                      |)
                                    |),
                                    [
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let γ0_0 :=
                                            M.SubPointer.get_struct_tuple_field (|
                                              γ,
                                              "core::ops::control_flow::ControlFlow::Break",
                                              0
                                            |) in
                                          let residual := M.copy (| γ0_0 |) in
                                          M.alloc (|
                                            M.never_to_any (|
                                              M.read (|
                                                M.return_ (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::ops::try_trait::FromResidual",
                                                      Ty.apply
                                                        (Ty.path "core::result::Result")
                                                        []
                                                        [
                                                          Ty.tuple [];
                                                          Ty.path
                                                            "move_binary_format::errors::PartialVMError"
                                                        ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::result::Result")
                                                          []
                                                          [
                                                            Ty.path "core::convert::Infallible";
                                                            Ty.path
                                                              "move_binary_format::errors::PartialVMError"
                                                          ]
                                                      ],
                                                      "from_residual",
                                                      []
                                                    |),
                                                    [ M.read (| residual |) ]
                                                  |)
                                                |)
                                              |)
                                            |)
                                          |)));
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let γ0_0 :=
                                            M.SubPointer.get_struct_tuple_field (|
                                              γ,
                                              "core::ops::control_flow::ControlFlow::Continue",
                                              0
                                            |) in
                                          let val := M.copy (| γ0_0 |) in
                                          val))
                                    ]
                                  |)
                                |) in
                              let~ next_block_candidate :=
                                M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "move_binary_format::control_flow_graph::ControlFlowGraph",
                                      Ty.path
                                        "move_binary_format::control_flow_graph::VMControlFlowGraph",
                                      [],
                                      "next_block",
                                      []
                                    |),
                                    [
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.path "move_bytecode_verifier::absint::FunctionContext",
                                          "cfg",
                                          []
                                        |),
                                        [ M.read (| function_context |) ]
                                      |);
                                      M.read (| block_id |)
                                    ]
                                  |)
                                |) in
                              let~ _ :=
                                M.use
                                  (M.match_operator (|
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::iter::traits::collect::IntoIterator",
                                          Ty.apply
                                            (Ty.path "&")
                                            []
                                            [
                                              Ty.apply
                                                (Ty.path "alloc::vec::Vec")
                                                []
                                                [ Ty.path "u16"; Ty.path "alloc::alloc::Global" ]
                                            ],
                                          [],
                                          "into_iter",
                                          []
                                        |),
                                        [
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "move_binary_format::control_flow_graph::ControlFlowGraph",
                                              Ty.path
                                                "move_binary_format::control_flow_graph::VMControlFlowGraph",
                                              [],
                                              "successors",
                                              []
                                            |),
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path
                                                    "move_bytecode_verifier::absint::FunctionContext",
                                                  "cfg",
                                                  []
                                                |),
                                                [ M.read (| function_context |) ]
                                              |);
                                              M.read (| block_id |)
                                            ]
                                          |)
                                        ]
                                      |)
                                    |),
                                    [
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let iter := M.copy (| γ |) in
                                          M.loop (|
                                            ltac:(M.monadic
                                              (let~ _ :=
                                                M.match_operator (|
                                                  M.alloc (|
                                                    M.call_closure (|
                                                      M.get_trait_method (|
                                                        "core::iter::traits::iterator::Iterator",
                                                        Ty.apply
                                                          (Ty.path "core::slice::iter::Iter")
                                                          []
                                                          [ Ty.path "u16" ],
                                                        [],
                                                        "next",
                                                        []
                                                      |),
                                                      [ iter ]
                                                    |)
                                                  |),
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let _ :=
                                                          M.is_struct_tuple (|
                                                            γ,
                                                            "core::option::Option::None"
                                                          |) in
                                                        M.alloc (|
                                                          M.never_to_any (|
                                                            M.read (| M.break (||) |)
                                                          |)
                                                        |)));
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let γ0_0 :=
                                                          M.SubPointer.get_struct_tuple_field (|
                                                            γ,
                                                            "core::option::Option::Some",
                                                            0
                                                          |) in
                                                        let successor_block_id :=
                                                          M.copy (| γ0_0 |) in
                                                        let~ _ :=
                                                          M.match_operator (|
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::ops::try_trait::Try",
                                                                  Ty.apply
                                                                    (Ty.path "core::result::Result")
                                                                    []
                                                                    [
                                                                      Ty.tuple [];
                                                                      Ty.path
                                                                        "move_binary_format::errors::PartialVMError"
                                                                    ],
                                                                  [],
                                                                  "branch",
                                                                  []
                                                                |),
                                                                [
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "move_bytecode_verifier_meter::Meter",
                                                                      impl_Meter__plus___Sized,
                                                                      [],
                                                                      "add",
                                                                      []
                                                                    |),
                                                                    [
                                                                      M.read (| meter |);
                                                                      Value.StructTuple
                                                                        "move_bytecode_verifier_meter::Scope::Function"
                                                                        [];
                                                                      M.read (|
                                                                        M.get_constant (|
                                                                          "move_bytecode_verifier::absint::PER_SUCCESSOR_COST"
                                                                        |)
                                                                      |)
                                                                    ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |),
                                                            [
                                                              fun γ =>
                                                                ltac:(M.monadic
                                                                  (let γ0_0 :=
                                                                    M.SubPointer.get_struct_tuple_field (|
                                                                      γ,
                                                                      "core::ops::control_flow::ControlFlow::Break",
                                                                      0
                                                                    |) in
                                                                  let residual :=
                                                                    M.copy (| γ0_0 |) in
                                                                  M.alloc (|
                                                                    M.never_to_any (|
                                                                      M.read (|
                                                                        M.return_ (|
                                                                          M.call_closure (|
                                                                            M.get_trait_method (|
                                                                              "core::ops::try_trait::FromResidual",
                                                                              Ty.apply
                                                                                (Ty.path
                                                                                  "core::result::Result")
                                                                                []
                                                                                [
                                                                                  Ty.tuple [];
                                                                                  Ty.path
                                                                                    "move_binary_format::errors::PartialVMError"
                                                                                ],
                                                                              [
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "core::result::Result")
                                                                                  []
                                                                                  [
                                                                                    Ty.path
                                                                                      "core::convert::Infallible";
                                                                                    Ty.path
                                                                                      "move_binary_format::errors::PartialVMError"
                                                                                  ]
                                                                              ],
                                                                              "from_residual",
                                                                              []
                                                                            |),
                                                                            [ M.read (| residual |)
                                                                            ]
                                                                          |)
                                                                        |)
                                                                      |)
                                                                    |)
                                                                  |)));
                                                              fun γ =>
                                                                ltac:(M.monadic
                                                                  (let γ0_0 :=
                                                                    M.SubPointer.get_struct_tuple_field (|
                                                                      γ,
                                                                      "core::ops::control_flow::ControlFlow::Continue",
                                                                      0
                                                                    |) in
                                                                  let val := M.copy (| γ0_0 |) in
                                                                  val))
                                                            ]
                                                          |) in
                                                        M.match_operator (|
                                                          M.alloc (|
                                                            M.call_closure (|
                                                              M.get_associated_function (|
                                                                Ty.apply
                                                                  (Ty.path
                                                                    "alloc::collections::btree::map::BTreeMap")
                                                                  []
                                                                  [
                                                                    Ty.path "u16";
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "move_bytecode_verifier::absint::BlockInvariant")
                                                                      []
                                                                      [ Ty.associated ];
                                                                    Ty.path "alloc::alloc::Global"
                                                                  ],
                                                                "get_mut",
                                                                [ Ty.path "u16" ]
                                                              |),
                                                              [
                                                                inv_map;
                                                                M.read (| successor_block_id |)
                                                              ]
                                                            |)
                                                          |),
                                                          [
                                                            fun γ =>
                                                              ltac:(M.monadic
                                                                (let γ0_0 :=
                                                                  M.SubPointer.get_struct_tuple_field (|
                                                                    γ,
                                                                    "core::option::Option::Some",
                                                                    0
                                                                  |) in
                                                                let next_block_invariant :=
                                                                  M.copy (| γ0_0 |) in
                                                                let~ join_result :=
                                                                  M.copy (|
                                                                    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.path
                                                                                  "move_bytecode_verifier::absint::JoinResult";
                                                                                Ty.path
                                                                                  "move_binary_format::errors::PartialVMError"
                                                                              ],
                                                                            [],
                                                                            "branch",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.read (|
                                                                              let~ old_pre :=
                                                                                M.alloc (|
                                                                                  M.SubPointer.get_struct_record_field (|
                                                                                    M.read (|
                                                                                      next_block_invariant
                                                                                    |),
                                                                                    "move_bytecode_verifier::absint::BlockInvariant",
                                                                                    "pre"
                                                                                  |)
                                                                                |) in
                                                                              M.alloc (|
                                                                                M.call_closure (|
                                                                                  M.get_trait_method (|
                                                                                    "move_bytecode_verifier::absint::AbstractDomain",
                                                                                    Ty.associated,
                                                                                    [],
                                                                                    "join",
                                                                                    [
                                                                                      impl_Meter__plus___Sized
                                                                                    ]
                                                                                  |),
                                                                                  [
                                                                                    M.read (|
                                                                                      old_pre
                                                                                    |);
                                                                                    post_state;
                                                                                    M.read (|
                                                                                      meter
                                                                                    |)
                                                                                  ]
                                                                                |)
                                                                              |)
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ0_0 :=
                                                                              M.SubPointer.get_struct_tuple_field (|
                                                                                γ,
                                                                                "core::ops::control_flow::ControlFlow::Break",
                                                                                0
                                                                              |) in
                                                                            let residual :=
                                                                              M.copy (| γ0_0 |) in
                                                                            M.alloc (|
                                                                              M.never_to_any (|
                                                                                M.read (|
                                                                                  M.return_ (|
                                                                                    M.call_closure (|
                                                                                      M.get_trait_method (|
                                                                                        "core::ops::try_trait::FromResidual",
                                                                                        Ty.apply
                                                                                          (Ty.path
                                                                                            "core::result::Result")
                                                                                          []
                                                                                          [
                                                                                            Ty.tuple
                                                                                              [];
                                                                                            Ty.path
                                                                                              "move_binary_format::errors::PartialVMError"
                                                                                          ],
                                                                                        [
                                                                                          Ty.apply
                                                                                            (Ty.path
                                                                                              "core::result::Result")
                                                                                            []
                                                                                            [
                                                                                              Ty.path
                                                                                                "core::convert::Infallible";
                                                                                              Ty.path
                                                                                                "move_binary_format::errors::PartialVMError"
                                                                                            ]
                                                                                        ],
                                                                                        "from_residual",
                                                                                        []
                                                                                      |),
                                                                                      [
                                                                                        M.read (|
                                                                                          residual
                                                                                        |)
                                                                                      ]
                                                                                    |)
                                                                                  |)
                                                                                |)
                                                                              |)
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ0_0 :=
                                                                              M.SubPointer.get_struct_tuple_field (|
                                                                                γ,
                                                                                "core::ops::control_flow::ControlFlow::Continue",
                                                                                0
                                                                              |) in
                                                                            let val :=
                                                                              M.copy (| γ0_0 |) in
                                                                            val))
                                                                      ]
                                                                    |)
                                                                  |) in
                                                                M.match_operator (|
                                                                  join_result,
                                                                  [
                                                                    fun γ =>
                                                                      ltac:(M.monadic
                                                                        (let _ :=
                                                                          M.is_struct_tuple (|
                                                                            γ,
                                                                            "move_bytecode_verifier::absint::JoinResult::Unchanged"
                                                                          |) in
                                                                        M.alloc (|
                                                                          Value.Tuple []
                                                                        |)));
                                                                    fun γ =>
                                                                      ltac:(M.monadic
                                                                        (let _ :=
                                                                          M.is_struct_tuple (|
                                                                            γ,
                                                                            "move_bytecode_verifier::absint::JoinResult::Changed"
                                                                          |) in
                                                                        M.match_operator (|
                                                                          M.alloc (|
                                                                            Value.Tuple []
                                                                          |),
                                                                          [
                                                                            fun γ =>
                                                                              ltac:(M.monadic
                                                                                (let γ :=
                                                                                  M.use
                                                                                    (M.alloc (|
                                                                                      M.call_closure (|
                                                                                        M.get_trait_method (|
                                                                                          "move_binary_format::control_flow_graph::ControlFlowGraph",
                                                                                          Ty.path
                                                                                            "move_binary_format::control_flow_graph::VMControlFlowGraph",
                                                                                          [],
                                                                                          "is_back_edge",
                                                                                          []
                                                                                        |),
                                                                                        [
                                                                                          M.call_closure (|
                                                                                            M.get_associated_function (|
                                                                                              Ty.path
                                                                                                "move_bytecode_verifier::absint::FunctionContext",
                                                                                              "cfg",
                                                                                              []
                                                                                            |),
                                                                                            [
                                                                                              M.read (|
                                                                                                function_context
                                                                                              |)
                                                                                            ]
                                                                                          |);
                                                                                          M.read (|
                                                                                            block_id
                                                                                          |);
                                                                                          M.read (|
                                                                                            M.read (|
                                                                                              successor_block_id
                                                                                            |)
                                                                                          |)
                                                                                        ]
                                                                                      |)
                                                                                    |)) in
                                                                                let _ :=
                                                                                  M.is_constant_or_break_match (|
                                                                                    M.read (| γ |),
                                                                                    Value.Bool true
                                                                                  |) in
                                                                                M.alloc (|
                                                                                  M.never_to_any (|
                                                                                    M.read (|
                                                                                      let~ _ :=
                                                                                        M.match_operator (|
                                                                                          M.alloc (|
                                                                                            M.call_closure (|
                                                                                              M.get_trait_method (|
                                                                                                "core::ops::try_trait::Try",
                                                                                                Ty.apply
                                                                                                  (Ty.path
                                                                                                    "core::result::Result")
                                                                                                  []
                                                                                                  [
                                                                                                    Ty.tuple
                                                                                                      [];
                                                                                                    Ty.path
                                                                                                      "move_binary_format::errors::PartialVMError"
                                                                                                  ],
                                                                                                [],
                                                                                                "branch",
                                                                                                []
                                                                                              |),
                                                                                              [
                                                                                                M.call_closure (|
                                                                                                  M.get_trait_method (|
                                                                                                    "move_bytecode_verifier_meter::Meter",
                                                                                                    impl_Meter__plus___Sized,
                                                                                                    [],
                                                                                                    "add",
                                                                                                    []
                                                                                                  |),
                                                                                                  [
                                                                                                    M.read (|
                                                                                                      meter
                                                                                                    |);
                                                                                                    Value.StructTuple
                                                                                                      "move_bytecode_verifier_meter::Scope::Function"
                                                                                                      [];
                                                                                                    M.read (|
                                                                                                      M.get_constant (|
                                                                                                        "move_bytecode_verifier::absint::PER_BACKEDGE_COST"
                                                                                                      |)
                                                                                                    |)
                                                                                                  ]
                                                                                                |)
                                                                                              ]
                                                                                            |)
                                                                                          |),
                                                                                          [
                                                                                            fun γ =>
                                                                                              ltac:(M.monadic
                                                                                                (let
                                                                                                      γ0_0 :=
                                                                                                  M.SubPointer.get_struct_tuple_field (|
                                                                                                    γ,
                                                                                                    "core::ops::control_flow::ControlFlow::Break",
                                                                                                    0
                                                                                                  |) in
                                                                                                let
                                                                                                      residual :=
                                                                                                  M.copy (|
                                                                                                    γ0_0
                                                                                                  |) in
                                                                                                M.alloc (|
                                                                                                  M.never_to_any (|
                                                                                                    M.read (|
                                                                                                      M.return_ (|
                                                                                                        M.call_closure (|
                                                                                                          M.get_trait_method (|
                                                                                                            "core::ops::try_trait::FromResidual",
                                                                                                            Ty.apply
                                                                                                              (Ty.path
                                                                                                                "core::result::Result")
                                                                                                              []
                                                                                                              [
                                                                                                                Ty.tuple
                                                                                                                  [];
                                                                                                                Ty.path
                                                                                                                  "move_binary_format::errors::PartialVMError"
                                                                                                              ],
                                                                                                            [
                                                                                                              Ty.apply
                                                                                                                (Ty.path
                                                                                                                  "core::result::Result")
                                                                                                                []
                                                                                                                [
                                                                                                                  Ty.path
                                                                                                                    "core::convert::Infallible";
                                                                                                                  Ty.path
                                                                                                                    "move_binary_format::errors::PartialVMError"
                                                                                                                ]
                                                                                                            ],
                                                                                                            "from_residual",
                                                                                                            []
                                                                                                          |),
                                                                                                          [
                                                                                                            M.read (|
                                                                                                              residual
                                                                                                            |)
                                                                                                          ]
                                                                                                        |)
                                                                                                      |)
                                                                                                    |)
                                                                                                  |)
                                                                                                |)));
                                                                                            fun γ =>
                                                                                              ltac:(M.monadic
                                                                                                (let
                                                                                                      γ0_0 :=
                                                                                                  M.SubPointer.get_struct_tuple_field (|
                                                                                                    γ,
                                                                                                    "core::ops::control_flow::ControlFlow::Continue",
                                                                                                    0
                                                                                                  |) in
                                                                                                let
                                                                                                      val :=
                                                                                                  M.copy (|
                                                                                                    γ0_0
                                                                                                  |) in
                                                                                                val))
                                                                                          ]
                                                                                        |) in
                                                                                      let~ _ :=
                                                                                        M.write (|
                                                                                          next_block_candidate,
                                                                                          Value.StructTuple
                                                                                            "core::option::Option::Some"
                                                                                            [
                                                                                              M.read (|
                                                                                                M.read (|
                                                                                                  successor_block_id
                                                                                                |)
                                                                                              |)
                                                                                            ]
                                                                                        |) in
                                                                                      M.break (||)
                                                                                    |)
                                                                                  |)
                                                                                |)));
                                                                            fun γ =>
                                                                              ltac:(M.monadic
                                                                                (M.alloc (|
                                                                                  Value.Tuple []
                                                                                |)))
                                                                          ]
                                                                        |)))
                                                                  ]
                                                                |)));
                                                            fun γ =>
                                                              ltac:(M.monadic
                                                                (let _ :=
                                                                  M.is_struct_tuple (|
                                                                    γ,
                                                                    "core::option::Option::None"
                                                                  |) in
                                                                let~ _ :=
                                                                  M.alloc (|
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "alloc::collections::btree::map::BTreeMap")
                                                                          []
                                                                          [
                                                                            Ty.path "u16";
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "move_bytecode_verifier::absint::BlockInvariant")
                                                                              []
                                                                              [ Ty.associated ];
                                                                            Ty.path
                                                                              "alloc::alloc::Global"
                                                                          ],
                                                                        "insert",
                                                                        []
                                                                      |),
                                                                      [
                                                                        inv_map;
                                                                        M.read (|
                                                                          M.read (|
                                                                            successor_block_id
                                                                          |)
                                                                        |);
                                                                        Value.StructRecord
                                                                          "move_bytecode_verifier::absint::BlockInvariant"
                                                                          [
                                                                            ("pre",
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::clone::Clone",
                                                                                  Ty.associated,
                                                                                  [],
                                                                                  "clone",
                                                                                  []
                                                                                |),
                                                                                [ post_state ]
                                                                              |))
                                                                          ]
                                                                      ]
                                                                    |)
                                                                  |) in
                                                                M.alloc (| Value.Tuple [] |)))
                                                          ]
                                                        |)))
                                                  ]
                                                |) in
                                              M.alloc (| Value.Tuple [] |)))
                                          |)))
                                    ]
                                  |)) in
                              let~ _ :=
                                M.write (| next_block, M.read (| next_block_candidate |) |) in
                              M.alloc (| Value.Tuple [] |)));
                          fun γ =>
                            ltac:(M.monadic
                              (M.alloc (|
                                M.never_to_any (|
                                  M.read (|
                                    let~ _ :=
                                      M.alloc (|
                                        M.never_to_any (| M.read (| M.break (||) |) |)
                                      |) in
                                    M.alloc (| Value.Tuple [] |)
                                  |)
                                |)
                              |)))
                        ]
                      |)))
                  |) in
                M.alloc (| Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ] |)
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom ProvidedMethod_analyze_function :
      M.IsProvidedMethod
        "move_bytecode_verifier::absint::AbstractInterpreter"
        "analyze_function"
        analyze_function.
    Definition execute_block
        (Self : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      match ε, τ, α with
      | [], [ impl_Meter__plus___Sized ], [ self; block_id; pre_state; function_context; meter ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let block_id := M.alloc (| block_id |) in
          let pre_state := M.alloc (| pre_state |) in
          let function_context := M.alloc (| function_context |) in
          let meter := M.alloc (| meter |) in
          M.catch_return (|
            ltac:(M.monadic
              (M.read (|
                let~ _ :=
                  M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::ops::try_trait::Try",
                          Ty.apply
                            (Ty.path "core::result::Result")
                            []
                            [ Ty.tuple []; Ty.path "move_binary_format::errors::PartialVMError" ],
                          [],
                          "branch",
                          []
                        |),
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "move_bytecode_verifier_meter::Meter",
                              impl_Meter__plus___Sized,
                              [],
                              "add",
                              []
                            |),
                            [
                              M.read (| meter |);
                              Value.StructTuple "move_bytecode_verifier_meter::Scope::Function" [];
                              M.read (|
                                M.get_constant (|
                                  "move_bytecode_verifier::absint::EXECUTE_BLOCK_BASE_COST"
                                |)
                              |)
                            ]
                          |)
                        ]
                      |)
                    |),
                    [
                      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.associated;
                                          Ty.path "move_binary_format::errors::PartialVMError"
                                        ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::result::Result")
                                          []
                                          [
                                            Ty.path "core::convert::Infallible";
                                            Ty.path "move_binary_format::errors::PartialVMError"
                                          ]
                                      ],
                                      "from_residual",
                                      []
                                    |),
                                    [ M.read (| residual |) ]
                                  |)
                                |)
                              |)
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::ops::control_flow::ControlFlow::Continue",
                              0
                            |) in
                          let val := M.copy (| γ0_0 |) in
                          val))
                    ]
                  |) in
                let~ state_acc :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::clone::Clone", Ty.associated, [], "clone", [] |),
                      [ M.read (| pre_state |) ]
                    |)
                  |) in
                let~ block_end :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "move_binary_format::control_flow_graph::ControlFlowGraph",
                        Ty.path "move_binary_format::control_flow_graph::VMControlFlowGraph",
                        [],
                        "block_end",
                        []
                      |),
                      [
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "move_bytecode_verifier::absint::FunctionContext",
                            "cfg",
                            []
                          |),
                          [ M.read (| function_context |) ]
                        |);
                        M.read (| block_id |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.use
                    (M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::iter::traits::collect::IntoIterator",
                            Ty.apply
                              (Ty.path "alloc::boxed::Box")
                              []
                              [
                                Ty.dyn [ ("core::iter::traits::iterator::Iterator::Trait", []) ];
                                Ty.path "alloc::alloc::Global"
                              ],
                            [],
                            "into_iter",
                            []
                          |),
                          [
                            M.call_closure (|
                              M.get_trait_method (|
                                "move_binary_format::control_flow_graph::ControlFlowGraph",
                                Ty.path
                                  "move_binary_format::control_flow_graph::VMControlFlowGraph",
                                [],
                                "instr_indexes",
                                []
                              |),
                              [
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path "move_bytecode_verifier::absint::FunctionContext",
                                    "cfg",
                                    []
                                  |),
                                  [ M.read (| function_context |) ]
                                |);
                                M.read (| block_id |)
                              ]
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let iter := M.copy (| γ |) in
                            M.loop (|
                              ltac:(M.monadic
                                (let~ _ :=
                                  M.match_operator (|
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::iter::traits::iterator::Iterator",
                                          Ty.apply
                                            (Ty.path "alloc::boxed::Box")
                                            []
                                            [
                                              Ty.dyn
                                                [
                                                  ("core::iter::traits::iterator::Iterator::Trait",
                                                    [])
                                                ];
                                              Ty.path "alloc::alloc::Global"
                                            ],
                                          [],
                                          "next",
                                          []
                                        |),
                                        [ iter ]
                                      |)
                                    |),
                                    [
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let _ :=
                                            M.is_struct_tuple (|
                                              γ,
                                              "core::option::Option::None"
                                            |) in
                                          M.alloc (|
                                            M.never_to_any (| M.read (| M.break (||) |) |)
                                          |)));
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let γ0_0 :=
                                            M.SubPointer.get_struct_tuple_field (|
                                              γ,
                                              "core::option::Option::Some",
                                              0
                                            |) in
                                          let offset := M.copy (| γ0_0 |) in
                                          let~ instr :=
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::ops::index::Index",
                                                  Ty.apply
                                                    (Ty.path "alloc::vec::Vec")
                                                    []
                                                    [
                                                      Ty.path
                                                        "move_binary_format::file_format::Bytecode";
                                                      Ty.path "alloc::alloc::Global"
                                                    ],
                                                  [ Ty.path "usize" ],
                                                  "index",
                                                  []
                                                |),
                                                [
                                                  M.SubPointer.get_struct_record_field (|
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path
                                                          "move_bytecode_verifier::absint::FunctionContext",
                                                        "code",
                                                        []
                                                      |),
                                                      [ M.read (| function_context |) ]
                                                    |),
                                                    "move_binary_format::file_format::CodeUnit",
                                                    "code"
                                                  |);
                                                  M.rust_cast (M.read (| offset |))
                                                ]
                                              |)
                                            |) in
                                          M.match_operator (|
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::ops::try_trait::Try",
                                                  Ty.apply
                                                    (Ty.path "core::result::Result")
                                                    []
                                                    [
                                                      Ty.tuple [];
                                                      Ty.path
                                                        "move_binary_format::errors::PartialVMError"
                                                    ],
                                                  [],
                                                  "branch",
                                                  []
                                                |),
                                                [
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "move_bytecode_verifier::absint::TransferFunctions",
                                                      Self,
                                                      [],
                                                      "execute",
                                                      [ impl_Meter__plus___Sized ]
                                                    |),
                                                    [
                                                      M.read (| self |);
                                                      state_acc;
                                                      M.read (| instr |);
                                                      M.read (| offset |);
                                                      M.read (| block_end |);
                                                      M.read (| meter |)
                                                    ]
                                                  |)
                                                ]
                                              |)
                                            |),
                                            [
                                              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.associated;
                                                                  Ty.path
                                                                    "move_binary_format::errors::PartialVMError"
                                                                ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::result::Result")
                                                                  []
                                                                  [
                                                                    Ty.path
                                                                      "core::convert::Infallible";
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                              ],
                                                              "from_residual",
                                                              []
                                                            |),
                                                            [ M.read (| residual |) ]
                                                          |)
                                                        |)
                                                      |)
                                                    |)
                                                  |)));
                                              fun γ =>
                                                ltac:(M.monadic
                                                  (let γ0_0 :=
                                                    M.SubPointer.get_struct_tuple_field (|
                                                      γ,
                                                      "core::ops::control_flow::ControlFlow::Continue",
                                                      0
                                                    |) in
                                                  let val := M.copy (| γ0_0 |) in
                                                  val))
                                            ]
                                          |)))
                                    ]
                                  |) in
                                M.alloc (| Value.Tuple [] |)))
                            |)))
                      ]
                    |)) in
                M.alloc (|
                  Value.StructTuple "core::result::Result::Ok" [ M.read (| state_acc |) ]
                |)
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom ProvidedMethod_execute_block :
      M.IsProvidedMethod
        "move_bytecode_verifier::absint::AbstractInterpreter"
        "execute_block"
        execute_block.
  End AbstractInterpreter.
  
  Module Impl_move_bytecode_verifier_absint_FunctionContext.
    Definition Self : Ty.t := Ty.path "move_bytecode_verifier::absint::FunctionContext".
    
    (*
        pub fn new(
            module: &'a CompiledModule,
            index: FunctionDefinitionIndex,
            code: &'a CodeUnit,
            function_handle: &'a FunctionHandle,
        ) -> Self {
            Self {
                index: Some(index),
                code,
                parameters: module.signature_at(function_handle.parameters),
                return_: module.signature_at(function_handle.return_),
                locals: module.signature_at(code.locals),
                type_parameters: &function_handle.type_parameters,
                cfg: VMControlFlowGraph::new(&code.code),
            }
        }
    *)
    Definition new (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ module; index; code; function_handle ] =>
        ltac:(M.monadic
          (let module := M.alloc (| module |) in
          let index := M.alloc (| index |) in
          let code := M.alloc (| code |) in
          let function_handle := M.alloc (| function_handle |) in
          Value.StructRecord
            "move_bytecode_verifier::absint::FunctionContext"
            [
              ("index", Value.StructTuple "core::option::Option::Some" [ M.read (| index |) ]);
              ("code", M.read (| code |));
              ("parameters",
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.path "move_binary_format::file_format::CompiledModule",
                    "signature_at",
                    []
                  |),
                  [
                    M.read (| module |);
                    M.read (|
                      M.SubPointer.get_struct_record_field (|
                        M.read (| function_handle |),
                        "move_binary_format::file_format::FunctionHandle",
                        "parameters"
                      |)
                    |)
                  ]
                |));
              ("return_",
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.path "move_binary_format::file_format::CompiledModule",
                    "signature_at",
                    []
                  |),
                  [
                    M.read (| module |);
                    M.read (|
                      M.SubPointer.get_struct_record_field (|
                        M.read (| function_handle |),
                        "move_binary_format::file_format::FunctionHandle",
                        "return_"
                      |)
                    |)
                  ]
                |));
              ("locals",
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.path "move_binary_format::file_format::CompiledModule",
                    "signature_at",
                    []
                  |),
                  [
                    M.read (| module |);
                    M.read (|
                      M.SubPointer.get_struct_record_field (|
                        M.read (| code |),
                        "move_binary_format::file_format::CodeUnit",
                        "locals"
                      |)
                    |)
                  ]
                |));
              ("type_parameters",
                M.call_closure (|
                  M.get_trait_method (|
                    "core::ops::deref::Deref",
                    Ty.apply
                      (Ty.path "alloc::vec::Vec")
                      []
                      [
                        Ty.path "move_binary_format::file_format::AbilitySet";
                        Ty.path "alloc::alloc::Global"
                      ],
                    [],
                    "deref",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| function_handle |),
                      "move_binary_format::file_format::FunctionHandle",
                      "type_parameters"
                    |)
                  ]
                |));
              ("cfg",
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.path "move_binary_format::control_flow_graph::VMControlFlowGraph",
                    "new",
                    []
                  |),
                  [
                    M.call_closure (|
                      M.get_trait_method (|
                        "core::ops::deref::Deref",
                        Ty.apply
                          (Ty.path "alloc::vec::Vec")
                          []
                          [
                            Ty.path "move_binary_format::file_format::Bytecode";
                            Ty.path "alloc::alloc::Global"
                          ],
                        [],
                        "deref",
                        []
                      |),
                      [
                        M.SubPointer.get_struct_record_field (|
                          M.read (| code |),
                          "move_binary_format::file_format::CodeUnit",
                          "code"
                        |)
                      ]
                    |)
                  ]
                |))
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_new : M.IsAssociatedFunction Self "new" new.
    
    (*
        pub fn index(&self) -> Option<FunctionDefinitionIndex> {
            self.index
        }
    *)
    Definition index (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.read (|
            M.SubPointer.get_struct_record_field (|
              M.read (| self |),
              "move_bytecode_verifier::absint::FunctionContext",
              "index"
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_index : M.IsAssociatedFunction Self "index" index.
    
    (*
        pub fn code(&self) -> &CodeUnit {
            self.code
        }
    *)
    Definition code (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.read (|
            M.SubPointer.get_struct_record_field (|
              M.read (| self |),
              "move_bytecode_verifier::absint::FunctionContext",
              "code"
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_code : M.IsAssociatedFunction Self "code" code.
    
    (*
        pub fn parameters(&self) -> &Signature {
            self.parameters
        }
    *)
    Definition parameters (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.read (|
            M.SubPointer.get_struct_record_field (|
              M.read (| self |),
              "move_bytecode_verifier::absint::FunctionContext",
              "parameters"
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_parameters : M.IsAssociatedFunction Self "parameters" parameters.
    
    (*
        pub fn return_(&self) -> &Signature {
            self.return_
        }
    *)
    Definition return_ (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.read (|
            M.SubPointer.get_struct_record_field (|
              M.read (| self |),
              "move_bytecode_verifier::absint::FunctionContext",
              "return_"
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_return_ : M.IsAssociatedFunction Self "return_" return_.
    
    (*
        pub fn locals(&self) -> &Signature {
            self.locals
        }
    *)
    Definition locals (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.read (|
            M.SubPointer.get_struct_record_field (|
              M.read (| self |),
              "move_bytecode_verifier::absint::FunctionContext",
              "locals"
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_locals : M.IsAssociatedFunction Self "locals" locals.
    
    (*
        pub fn type_parameters(&self) -> &[AbilitySet] {
            self.type_parameters
        }
    *)
    Definition type_parameters (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.read (|
            M.SubPointer.get_struct_record_field (|
              M.read (| self |),
              "move_bytecode_verifier::absint::FunctionContext",
              "type_parameters"
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_type_parameters :
      M.IsAssociatedFunction Self "type_parameters" type_parameters.
    
    (*
        pub fn cfg(&self) -> &VMControlFlowGraph {
            &self.cfg
        }
    *)
    Definition cfg (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          M.SubPointer.get_struct_record_field (|
            M.read (| self |),
            "move_bytecode_verifier::absint::FunctionContext",
            "cfg"
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_cfg : M.IsAssociatedFunction Self "cfg" cfg.
  End Impl_move_bytecode_verifier_absint_FunctionContext.
End absint.
