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

Module type_safety.
  (* StructRecord
    {
      name := "Locals";
      const_params := [];
      ty_params := [];
      fields :=
        [
          ("param_count", Ty.path "usize");
          ("parameters",
            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" ])
        ];
    } *)
  
  Definition value_TYPE_NODE_COST : Value.t :=
    M.run ltac:(M.monadic (M.alloc (| Value.Integer IntegerKind.U128 30 |))).
  
  Module Impl_move_bytecode_verifier_type_safety_Locals.
    Definition Self : Ty.t := Ty.path "move_bytecode_verifier::type_safety::Locals".
    
    (*
        fn new(parameters: &'a Signature, locals: &'a Signature) -> Self {
            Self {
                param_count: parameters.len(),
                parameters,
                locals,
            }
        }
    *)
    Definition new (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ parameters; locals ] =>
        ltac:(M.monadic
          (let parameters := M.alloc (| parameters |) in
          let locals := M.alloc (| locals |) in
          Value.StructRecord
            "move_bytecode_verifier::type_safety::Locals"
            [
              ("param_count",
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.path "move_binary_format::file_format::Signature",
                    "len",
                    []
                  |),
                  [ M.read (| parameters |) ]
                |));
              ("parameters", M.read (| parameters |));
              ("locals", M.read (| locals |))
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_new : M.IsAssociatedFunction Self "new" new.
    
    (*
        fn local_at(&self, i: LocalIndex) -> &SignatureToken {
            let idx = i as usize;
            if idx < self.param_count {
                &self.parameters.0[idx]
            } else {
                &self.locals.0[idx - self.param_count]
            }
        }
    *)
    Definition local_at (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; i ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let i := M.alloc (| i |) in
          M.read (|
            let~ idx := M.alloc (| M.rust_cast (M.read (| i |)) |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          BinOp.lt (|
                            M.read (| idx |),
                            M.read (|
                              M.SubPointer.get_struct_record_field (|
                                M.read (| self |),
                                "move_bytecode_verifier::type_safety::Locals",
                                "param_count"
                              |)
                            |)
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    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::SignatureToken";
                              Ty.path "alloc::alloc::Global"
                            ],
                          [ Ty.path "usize" ],
                          "index",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_tuple_field (|
                            M.read (|
                              M.SubPointer.get_struct_record_field (|
                                M.read (| self |),
                                "move_bytecode_verifier::type_safety::Locals",
                                "parameters"
                              |)
                            |),
                            "move_binary_format::file_format::Signature",
                            0
                          |);
                          M.read (| idx |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (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::SignatureToken";
                              Ty.path "alloc::alloc::Global"
                            ],
                          [ Ty.path "usize" ],
                          "index",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_tuple_field (|
                            M.read (|
                              M.SubPointer.get_struct_record_field (|
                                M.read (| self |),
                                "move_bytecode_verifier::type_safety::Locals",
                                "locals"
                              |)
                            |),
                            "move_binary_format::file_format::Signature",
                            0
                          |);
                          BinOp.Wrap.sub (|
                            M.read (| idx |),
                            M.read (|
                              M.SubPointer.get_struct_record_field (|
                                M.read (| self |),
                                "move_bytecode_verifier::type_safety::Locals",
                                "param_count"
                              |)
                            |)
                          |)
                        ]
                      |)
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_local_at : M.IsAssociatedFunction Self "local_at" local_at.
  End Impl_move_bytecode_verifier_type_safety_Locals.
  
  (* StructRecord
    {
      name := "TypeSafetyChecker";
      const_params := [];
      ty_params := [];
      fields :=
        [
          ("module",
            Ty.apply
              (Ty.path "&")
              []
              [ Ty.path "move_binary_format::file_format::CompiledModule" ]);
          ("function_context",
            Ty.apply
              (Ty.path "&")
              []
              [ Ty.path "move_bytecode_verifier::absint::FunctionContext" ]);
          ("locals", Ty.path "move_bytecode_verifier::type_safety::Locals");
          ("stack",
            Ty.apply
              (Ty.path "move_abstract_stack::AbstractStack")
              []
              [ Ty.path "move_binary_format::file_format::SignatureToken" ])
        ];
    } *)
  
  Module Impl_move_bytecode_verifier_type_safety_TypeSafetyChecker.
    Definition Self : Ty.t := Ty.path "move_bytecode_verifier::type_safety::TypeSafetyChecker".
    
    (*
        fn new(module: &'a CompiledModule, function_context: &'a FunctionContext<'a>) -> Self {
            let locals = Locals::new(function_context.parameters(), function_context.locals());
            Self {
                module,
                function_context,
                locals,
                stack: AbstractStack::new(),
            }
        }
    *)
    Definition new (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ module; function_context ] =>
        ltac:(M.monadic
          (let module := M.alloc (| module |) in
          let function_context := M.alloc (| function_context |) in
          M.read (|
            let~ locals :=
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.path "move_bytecode_verifier::type_safety::Locals",
                    "new",
                    []
                  |),
                  [
                    M.call_closure (|
                      M.get_associated_function (|
                        Ty.path "move_bytecode_verifier::absint::FunctionContext",
                        "parameters",
                        []
                      |),
                      [ M.read (| function_context |) ]
                    |);
                    M.call_closure (|
                      M.get_associated_function (|
                        Ty.path "move_bytecode_verifier::absint::FunctionContext",
                        "locals",
                        []
                      |),
                      [ M.read (| function_context |) ]
                    |)
                  ]
                |)
              |) in
            M.alloc (|
              Value.StructRecord
                "move_bytecode_verifier::type_safety::TypeSafetyChecker"
                [
                  ("module", M.read (| module |));
                  ("function_context", M.read (| function_context |));
                  ("locals", M.read (| locals |));
                  ("stack",
                    M.call_closure (|
                      M.get_associated_function (|
                        Ty.apply
                          (Ty.path "move_abstract_stack::AbstractStack")
                          []
                          [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                        "new",
                        []
                      |),
                      []
                    |))
                ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_new : M.IsAssociatedFunction Self "new" new.
    
    (*
        fn local_at(&self, i: LocalIndex) -> &SignatureToken {
            self.locals.local_at(i)
        }
    *)
    Definition local_at (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; i ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let i := M.alloc (| i |) in
          M.call_closure (|
            M.get_associated_function (|
              Ty.path "move_bytecode_verifier::type_safety::Locals",
              "local_at",
              []
            |),
            [
              M.SubPointer.get_struct_record_field (|
                M.read (| self |),
                "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                "locals"
              |);
              M.read (| i |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_local_at : M.IsAssociatedFunction Self "local_at" local_at.
    
    (*
        fn abilities(&self, t: &SignatureToken) -> PartialVMResult<AbilitySet> {
            self.module
                .abilities(t, self.function_context.type_parameters())
        }
    *)
    Definition abilities (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; t ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let t := M.alloc (| t |) in
          M.call_closure (|
            M.get_associated_function (|
              Ty.path "move_binary_format::file_format::CompiledModule",
              "abilities",
              []
            |),
            [
              M.read (|
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                  "module"
                |)
              |);
              M.read (| t |);
              M.call_closure (|
                M.get_associated_function (|
                  Ty.path "move_bytecode_verifier::absint::FunctionContext",
                  "type_parameters",
                  []
                |),
                [
                  M.read (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                      "function_context"
                    |)
                  |)
                ]
              |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_abilities : M.IsAssociatedFunction Self "abilities" abilities.
    
    (*
        fn error(&self, status: StatusCode, offset: CodeOffset) -> PartialVMError {
            PartialVMError::new(status).at_code_offset(
                self.function_context
                    .index()
                    .unwrap_or(FunctionDefinitionIndex(0)),
                offset,
            )
        }
    *)
    Definition error (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; status; offset ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let status := M.alloc (| status |) in
          let offset := M.alloc (| offset |) in
          M.call_closure (|
            M.get_associated_function (|
              Ty.path "move_binary_format::errors::PartialVMError",
              "at_code_offset",
              []
            |),
            [
              M.call_closure (|
                M.get_associated_function (|
                  Ty.path "move_binary_format::errors::PartialVMError",
                  "new",
                  []
                |),
                [ M.read (| status |) ]
              |);
              M.call_closure (|
                M.get_associated_function (|
                  Ty.apply
                    (Ty.path "core::option::Option")
                    []
                    [ Ty.path "move_binary_format::file_format::FunctionDefinitionIndex" ],
                  "unwrap_or",
                  []
                |),
                [
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "move_bytecode_verifier::absint::FunctionContext",
                      "index",
                      []
                    |),
                    [
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                          "function_context"
                        |)
                      |)
                    ]
                  |);
                  Value.StructTuple
                    "move_binary_format::file_format::FunctionDefinitionIndex"
                    [ Value.Integer IntegerKind.U16 0 ]
                ]
              |);
              M.read (| offset |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_error : M.IsAssociatedFunction Self "error" error.
    
    (*
        fn push(
            &mut self,
            meter: &mut (impl Meter + ?Sized),
            ty: SignatureToken,
        ) -> PartialVMResult<()> {
            self.charge_ty(meter, &ty)?;
            safe_unwrap_err!(self.stack.push(ty));
            Ok(())
        }
    *)
    Definition push (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [ impl_Meter__plus___Sized ], [ self; meter; ty ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let meter := M.alloc (| meter |) in
          let ty := M.alloc (| ty |) 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_associated_function (|
                              Ty.path "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                              "charge_ty",
                              [ impl_Meter__plus___Sized ]
                            |),
                            [ M.read (| self |); M.read (| meter |); ty ]
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::ops::control_flow::ControlFlow::Break",
                              0
                            |) in
                          let residual := M.copy (| γ0_0 |) in
                          M.alloc (|
                            M.never_to_any (|
                              M.read (|
                                M.return_ (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::ops::try_trait::FromResidual",
                                      Ty.apply
                                        (Ty.path "core::result::Result")
                                        []
                                        [
                                          Ty.tuple [];
                                          Ty.path "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.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.apply
                            (Ty.path "move_abstract_stack::AbstractStack")
                            []
                            [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                          "push",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| self |),
                            "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                            "stack"
                          |);
                          M.read (| ty |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Ok",
                              0
                            |) in
                          let x := M.copy (| γ0_0 |) in
                          x));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Err",
                              0
                            |) in
                          let e := M.copy (| γ0_0 |) in
                          let~ err :=
                            M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::errors::PartialVMError",
                                  "with_message",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::errors::PartialVMError",
                                      "new",
                                      []
                                    |),
                                    [
                                      Value.StructTuple
                                        "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                        []
                                    ]
                                  |);
                                  M.call_closure (|
                                    M.get_function (|
                                      "core::hint::must_use",
                                      [ Ty.path "alloc::string::String" ]
                                    |),
                                    [
                                      M.read (|
                                        let~ res :=
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_function (| "alloc::fmt::format", [] |),
                                              [
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "core::fmt::Arguments",
                                                    "new_v1_formatted",
                                                    []
                                                  |),
                                                  [
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.read (|
                                                            Value.String
                                                              "crates/move-bytecode-verifier/src/type_safety.rs:95 "
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Argument",
                                                              "new_display",
                                                              [
                                                                Ty.path
                                                                  "move_abstract_stack::AbsStackError"
                                                              ]
                                                            |),
                                                            [ e ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Placeholder",
                                                              "new",
                                                              []
                                                            |),
                                                            [
                                                              Value.Integer IntegerKind.Usize 0;
                                                              Value.UnicodeChar 32;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Alignment::Unknown"
                                                                [];
                                                              Value.Integer IntegerKind.U32 4;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                [];
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                []
                                                            ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::UnsafeArg",
                                                        "new",
                                                        []
                                                      |),
                                                      []
                                                    |)
                                                  ]
                                                |)
                                              ]
                                            |)
                                          |) in
                                        res
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |) in
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.call_closure (|
                                        M.get_function (| "core::panicking::panic_fmt", [] |),
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "core::fmt::Arguments",
                                              "new_v1",
                                              []
                                            |),
                                            [
                                              M.alloc (|
                                                Value.Array [ M.read (| Value.String "" |) ]
                                              |);
                                              M.alloc (|
                                                Value.Array
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::Argument",
                                                        "new_debug",
                                                        [
                                                          Ty.path
                                                            "move_binary_format::errors::PartialVMError"
                                                        ]
                                                      |),
                                                      [ err ]
                                                    |)
                                                  ]
                                              |)
                                            ]
                                          |)
                                        ]
                                      |)
                                    |)
                                  |)));
                              fun γ =>
                                ltac:(M.monadic
                                  (M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [ M.read (| err |) ]
                                        |)
                                      |)
                                    |)
                                  |)))
                            ]
                          |)))
                    ]
                  |) in
                M.alloc (| Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ] |)
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_push : M.IsAssociatedFunction Self "push" push.
    
    (*
        fn push_n(
            &mut self,
            meter: &mut (impl Meter + ?Sized),
            ty: SignatureToken,
            n: u64,
        ) -> PartialVMResult<()> {
            self.charge_ty(meter, &ty)?;
            safe_unwrap_err!(self.stack.push_n(ty, n));
            Ok(())
        }
    *)
    Definition push_n (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [ impl_Meter__plus___Sized ], [ self; meter; ty; n ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let meter := M.alloc (| meter |) in
          let ty := M.alloc (| ty |) in
          let n := M.alloc (| n |) 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_associated_function (|
                              Ty.path "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                              "charge_ty",
                              [ impl_Meter__plus___Sized ]
                            |),
                            [ M.read (| self |); M.read (| meter |); ty ]
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::ops::control_flow::ControlFlow::Break",
                              0
                            |) in
                          let residual := M.copy (| γ0_0 |) in
                          M.alloc (|
                            M.never_to_any (|
                              M.read (|
                                M.return_ (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::ops::try_trait::FromResidual",
                                      Ty.apply
                                        (Ty.path "core::result::Result")
                                        []
                                        [
                                          Ty.tuple [];
                                          Ty.path "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.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.apply
                            (Ty.path "move_abstract_stack::AbstractStack")
                            []
                            [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                          "push_n",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| self |),
                            "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                            "stack"
                          |);
                          M.read (| ty |);
                          M.read (| n |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Ok",
                              0
                            |) in
                          let x := M.copy (| γ0_0 |) in
                          x));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Err",
                              0
                            |) in
                          let e := M.copy (| γ0_0 |) in
                          let~ err :=
                            M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::errors::PartialVMError",
                                  "with_message",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::errors::PartialVMError",
                                      "new",
                                      []
                                    |),
                                    [
                                      Value.StructTuple
                                        "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                        []
                                    ]
                                  |);
                                  M.call_closure (|
                                    M.get_function (|
                                      "core::hint::must_use",
                                      [ Ty.path "alloc::string::String" ]
                                    |),
                                    [
                                      M.read (|
                                        let~ res :=
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_function (| "alloc::fmt::format", [] |),
                                              [
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "core::fmt::Arguments",
                                                    "new_v1_formatted",
                                                    []
                                                  |),
                                                  [
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.read (|
                                                            Value.String
                                                              "crates/move-bytecode-verifier/src/type_safety.rs:106 "
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Argument",
                                                              "new_display",
                                                              [
                                                                Ty.path
                                                                  "move_abstract_stack::AbsStackError"
                                                              ]
                                                            |),
                                                            [ e ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Placeholder",
                                                              "new",
                                                              []
                                                            |),
                                                            [
                                                              Value.Integer IntegerKind.Usize 0;
                                                              Value.UnicodeChar 32;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Alignment::Unknown"
                                                                [];
                                                              Value.Integer IntegerKind.U32 4;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                [];
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                []
                                                            ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::UnsafeArg",
                                                        "new",
                                                        []
                                                      |),
                                                      []
                                                    |)
                                                  ]
                                                |)
                                              ]
                                            |)
                                          |) in
                                        res
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |) in
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.call_closure (|
                                        M.get_function (| "core::panicking::panic_fmt", [] |),
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "core::fmt::Arguments",
                                              "new_v1",
                                              []
                                            |),
                                            [
                                              M.alloc (|
                                                Value.Array [ M.read (| Value.String "" |) ]
                                              |);
                                              M.alloc (|
                                                Value.Array
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::Argument",
                                                        "new_debug",
                                                        [
                                                          Ty.path
                                                            "move_binary_format::errors::PartialVMError"
                                                        ]
                                                      |),
                                                      [ err ]
                                                    |)
                                                  ]
                                              |)
                                            ]
                                          |)
                                        ]
                                      |)
                                    |)
                                  |)));
                              fun γ =>
                                ltac:(M.monadic
                                  (M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [ M.read (| err |) ]
                                        |)
                                      |)
                                    |)
                                  |)))
                            ]
                          |)))
                    ]
                  |) in
                M.alloc (| Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ] |)
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_push_n : M.IsAssociatedFunction Self "push_n" push_n.
    
    (*
        fn charge_ty(
            &mut self,
            meter: &mut (impl Meter + ?Sized),
            ty: &SignatureToken,
        ) -> PartialVMResult<()> {
            self.charge_ty_(meter, ty, 1)
        }
    *)
    Definition charge_ty (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [ impl_Meter__plus___Sized ], [ self; meter; ty ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let meter := M.alloc (| meter |) in
          let ty := M.alloc (| ty |) in
          M.call_closure (|
            M.get_associated_function (|
              Ty.path "move_bytecode_verifier::type_safety::TypeSafetyChecker",
              "charge_ty_",
              [ impl_Meter__plus___Sized ]
            |),
            [
              M.read (| self |);
              M.read (| meter |);
              M.read (| ty |);
              Value.Integer IntegerKind.U64 1
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_charge_ty : M.IsAssociatedFunction Self "charge_ty" charge_ty.
    
    (*
        fn charge_ty_(
            &mut self,
            meter: &mut (impl Meter + ?Sized),
            ty: &SignatureToken,
            n: u64,
        ) -> PartialVMResult<()> {
            meter.add_items(
                Scope::Function,
                TYPE_NODE_COST,
                ty.preorder_traversal().count() * (n as usize),
            )
        }
    *)
    Definition charge_ty_ (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [ impl_Meter__plus___Sized ], [ self; meter; ty; n ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let meter := M.alloc (| meter |) in
          let ty := M.alloc (| ty |) in
          let n := M.alloc (| n |) in
          M.call_closure (|
            M.get_trait_method (|
              "move_bytecode_verifier_meter::Meter",
              impl_Meter__plus___Sized,
              [],
              "add_items",
              []
            |),
            [
              M.read (| meter |);
              Value.StructTuple "move_bytecode_verifier_meter::Scope::Function" [];
              M.read (|
                M.get_constant (| "move_bytecode_verifier::type_safety::TYPE_NODE_COST" |)
              |);
              BinOp.Wrap.mul (|
                M.call_closure (|
                  M.get_trait_method (|
                    "core::iter::traits::iterator::Iterator",
                    Ty.path "move_binary_format::file_format::SignatureTokenPreorderTraversalIter",
                    [],
                    "count",
                    []
                  |),
                  [
                    M.call_closure (|
                      M.get_associated_function (|
                        Ty.path "move_binary_format::file_format::SignatureToken",
                        "preorder_traversal",
                        []
                      |),
                      [ M.read (| ty |) ]
                    |)
                  ]
                |),
                M.rust_cast (M.read (| n |))
              |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_charge_ty_ : M.IsAssociatedFunction Self "charge_ty_" charge_ty_.
    
    (*
        fn charge_tys(
            &mut self,
            meter: &mut (impl Meter + ?Sized),
            tys: &[SignatureToken],
        ) -> PartialVMResult<()> {
            for ty in tys {
                self.charge_ty(meter, ty)?
            }
            Ok(())
        }
    *)
    Definition charge_tys (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [ impl_Meter__plus___Sized ], [ self; meter; tys ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let meter := M.alloc (| meter |) in
          let tys := M.alloc (| tys |) in
          M.catch_return (|
            ltac:(M.monadic
              (M.read (|
                let~ _ :=
                  M.use
                    (M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::iter::traits::collect::IntoIterator",
                            Ty.apply
                              (Ty.path "&")
                              []
                              [
                                Ty.apply
                                  (Ty.path "slice")
                                  []
                                  [ Ty.path "move_binary_format::file_format::SignatureToken" ]
                              ],
                            [],
                            "into_iter",
                            []
                          |),
                          [ M.read (| tys |) ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let iter := M.copy (| γ |) in
                            M.loop (|
                              ltac:(M.monadic
                                (let~ _ :=
                                  M.match_operator (|
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::iter::traits::iterator::Iterator",
                                          Ty.apply
                                            (Ty.path "core::slice::iter::Iter")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken"
                                            ],
                                          [],
                                          "next",
                                          []
                                        |),
                                        [ iter ]
                                      |)
                                    |),
                                    [
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let _ :=
                                            M.is_struct_tuple (|
                                              γ,
                                              "core::option::Option::None"
                                            |) in
                                          M.alloc (|
                                            M.never_to_any (| M.read (| M.break (||) |) |)
                                          |)));
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let γ0_0 :=
                                            M.SubPointer.get_struct_tuple_field (|
                                              γ,
                                              "core::option::Option::Some",
                                              0
                                            |) in
                                          let ty := M.copy (| γ0_0 |) in
                                          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_associated_function (|
                                                      Ty.path
                                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                      "charge_ty",
                                                      [ impl_Meter__plus___Sized ]
                                                    |),
                                                    [
                                                      M.read (| self |);
                                                      M.read (| meter |);
                                                      M.read (| ty |)
                                                    ]
                                                  |)
                                                ]
                                              |)
                                            |),
                                            [
                                              fun γ =>
                                                ltac:(M.monadic
                                                  (let γ0_0 :=
                                                    M.SubPointer.get_struct_tuple_field (|
                                                      γ,
                                                      "core::ops::control_flow::ControlFlow::Break",
                                                      0
                                                    |) in
                                                  let residual := M.copy (| γ0_0 |) in
                                                  M.alloc (|
                                                    M.never_to_any (|
                                                      M.read (|
                                                        M.return_ (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::ops::try_trait::FromResidual",
                                                              Ty.apply
                                                                (Ty.path "core::result::Result")
                                                                []
                                                                [
                                                                  Ty.tuple [];
                                                                  Ty.path
                                                                    "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" [ Value.Tuple [] ] |)
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_charge_tys : M.IsAssociatedFunction Self "charge_tys" charge_tys.
  End Impl_move_bytecode_verifier_type_safety_TypeSafetyChecker.
  
  (*
  pub(crate) fn verify<'a>(
      module: &'a CompiledModule,
      function_context: &'a FunctionContext<'a>,
      meter: &mut (impl Meter + ?Sized),
  ) -> PartialVMResult<()> {
      let verifier = &mut TypeSafetyChecker::new(module, function_context);
  
      for block_id in function_context.cfg().blocks() {
          for offset in function_context.cfg().instr_indexes(block_id) {
              let instr = &verifier.function_context.code().code[offset as usize];
              verify_instr(verifier, instr, offset, meter)?
          }
      }
  
      Ok(())
  }
  *)
  Definition verify (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [ impl_Meter__plus___Sized ], [ module; function_context; meter ] =>
      ltac:(M.monadic
        (let module := M.alloc (| module |) in
        let function_context := M.alloc (| function_context |) in
        let meter := M.alloc (| meter |) in
        M.catch_return (|
          ltac:(M.monadic
            (M.read (|
              let~ verifier :=
                M.alloc (|
                  M.alloc (|
                    M.call_closure (|
                      M.get_associated_function (|
                        Ty.path "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                        "new",
                        []
                      |),
                      [ M.read (| module |); M.read (| function_context |) ]
                    |)
                  |)
                |) 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::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",
                              [],
                              "blocks",
                              []
                            |),
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_bytecode_verifier::absint::FunctionContext",
                                  "cfg",
                                  []
                                |),
                                [ M.read (| function_context |) ]
                              |)
                            ]
                          |)
                        ]
                      |)
                    |),
                    [
                      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::vec::into_iter::IntoIter")
                                          []
                                          [ Ty.path "u16"; 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 block_id := M.copy (| γ0_0 |) in
                                        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 (|
                                                                                M.SubPointer.get_struct_record_field (|
                                                                                  M.read (|
                                                                                    verifier
                                                                                  |),
                                                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                                                  "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_function (|
                                                                            "move_bytecode_verifier::type_safety::verify_instr",
                                                                            [
                                                                              impl_Meter__plus___Sized
                                                                            ]
                                                                          |),
                                                                          [
                                                                            M.read (| verifier |);
                                                                            M.read (| instr |);
                                                                            M.read (| offset |);
                                                                            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.alloc (| Value.Tuple [] |)))
                                                  |)))
                                            ]
                                          |))))
                                  ]
                                |) in
                              M.alloc (| Value.Tuple [] |)))
                          |)))
                    ]
                  |)) in
              M.alloc (| Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ] |)
            |)))
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_verify : M.IsFunction "move_bytecode_verifier::type_safety::verify" verify.
  
  (*
  fn borrow_field(
      verifier: &mut TypeSafetyChecker,
      meter: &mut (impl Meter + ?Sized),
      offset: CodeOffset,
      mut_: bool,
      field_handle_index: FieldHandleIndex,
      type_args: &Signature,
  ) -> PartialVMResult<()> {
      // load operand and check mutability constraints
      let operand = safe_unwrap_err!(verifier.stack.pop());
      if mut_ && !operand.is_mutable_reference() {
          return Err(verifier.error(StatusCode::BORROWFIELD_TYPE_MISMATCH_ERROR, offset));
      }
  
      // check the reference on the stack is the expected type.
      // Load the type that owns the field according to the instruction.
      // For generic fields access, this step materializes that type
      let field_handle = verifier.module.field_handle_at(field_handle_index);
      let struct_def = verifier.module.struct_def_at(field_handle.owner);
      let expected_type = materialize_type(struct_def.struct_handle, type_args);
      match operand {
          ST::Reference(inner) | ST::MutableReference(inner) if expected_type == *inner => (),
          _ => return Err(verifier.error(StatusCode::BORROWFIELD_TYPE_MISMATCH_ERROR, offset)),
      }
  
      let field_def = match &struct_def.field_information {
          StructFieldInformation::Native => {
              return Err(verifier.error(StatusCode::BORROWFIELD_BAD_FIELD_ERROR, offset));
          }
          StructFieldInformation::Declared(fields) => {
              // TODO: review the whole error story here, way too much is left to chances...
              // definition of a more proper OM for the verifier could work around the problem
              // (maybe, maybe not..)
              &fields[field_handle.field as usize]
          }
      };
      let field_type = Box::new(instantiate(&field_def.signature.0, type_args));
      verifier.push(
          meter,
          if mut_ {
              ST::MutableReference(field_type)
          } else {
              ST::Reference(field_type)
          },
      )?;
      Ok(())
  }
  *)
  Definition borrow_field (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [],
        [ impl_Meter__plus___Sized ],
        [ verifier; meter; offset; mut_; field_handle_index; type_args ] =>
      ltac:(M.monadic
        (let verifier := M.alloc (| verifier |) in
        let meter := M.alloc (| meter |) in
        let offset := M.alloc (| offset |) in
        let mut_ := M.alloc (| mut_ |) in
        let field_handle_index := M.alloc (| field_handle_index |) in
        let type_args := M.alloc (| type_args |) in
        M.catch_return (|
          ltac:(M.monadic
            (M.read (|
              let~ operand :=
                M.copy (|
                  M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.apply
                            (Ty.path "move_abstract_stack::AbstractStack")
                            []
                            [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                          "pop",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| verifier |),
                            "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                            "stack"
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Ok",
                              0
                            |) in
                          let x := M.copy (| γ0_0 |) in
                          x));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Err",
                              0
                            |) in
                          let e := M.copy (| γ0_0 |) in
                          let~ err :=
                            M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::errors::PartialVMError",
                                  "with_message",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::errors::PartialVMError",
                                      "new",
                                      []
                                    |),
                                    [
                                      Value.StructTuple
                                        "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                        []
                                    ]
                                  |);
                                  M.call_closure (|
                                    M.get_function (|
                                      "core::hint::must_use",
                                      [ Ty.path "alloc::string::String" ]
                                    |),
                                    [
                                      M.read (|
                                        let~ res :=
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_function (| "alloc::fmt::format", [] |),
                                              [
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "core::fmt::Arguments",
                                                    "new_v1_formatted",
                                                    []
                                                  |),
                                                  [
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.read (|
                                                            Value.String
                                                              "crates/move-bytecode-verifier/src/type_safety.rs:170 "
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Argument",
                                                              "new_display",
                                                              [
                                                                Ty.path
                                                                  "move_abstract_stack::AbsStackError"
                                                              ]
                                                            |),
                                                            [ e ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Placeholder",
                                                              "new",
                                                              []
                                                            |),
                                                            [
                                                              Value.Integer IntegerKind.Usize 0;
                                                              Value.UnicodeChar 32;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Alignment::Unknown"
                                                                [];
                                                              Value.Integer IntegerKind.U32 4;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                [];
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                []
                                                            ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::UnsafeArg",
                                                        "new",
                                                        []
                                                      |),
                                                      []
                                                    |)
                                                  ]
                                                |)
                                              ]
                                            |)
                                          |) in
                                        res
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |) in
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.call_closure (|
                                        M.get_function (| "core::panicking::panic_fmt", [] |),
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "core::fmt::Arguments",
                                              "new_v1",
                                              []
                                            |),
                                            [
                                              M.alloc (|
                                                Value.Array [ M.read (| Value.String "" |) ]
                                              |);
                                              M.alloc (|
                                                Value.Array
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::Argument",
                                                        "new_debug",
                                                        [
                                                          Ty.path
                                                            "move_binary_format::errors::PartialVMError"
                                                        ]
                                                      |),
                                                      [ err ]
                                                    |)
                                                  ]
                                              |)
                                            ]
                                          |)
                                        ]
                                      |)
                                    |)
                                  |)));
                              fun γ =>
                                ltac:(M.monadic
                                  (M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [ M.read (| err |) ]
                                        |)
                                      |)
                                    |)
                                  |)))
                            ]
                          |)))
                    ]
                  |)
                |) in
              let~ _ :=
                M.match_operator (|
                  M.alloc (| Value.Tuple [] |),
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ :=
                          M.use
                            (M.alloc (|
                              LogicalOp.and (|
                                M.read (| mut_ |),
                                ltac:(M.monadic
                                  (UnOp.not (|
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path "move_binary_format::file_format::SignatureToken",
                                        "is_mutable_reference",
                                        []
                                      |),
                                      [ operand ]
                                    |)
                                  |)))
                              |)
                            |)) in
                        let _ :=
                          M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                        M.alloc (|
                          M.never_to_any (|
                            M.read (|
                              M.return_ (|
                                Value.StructTuple
                                  "core::result::Result::Err"
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                        "error",
                                        []
                                      |),
                                      [
                                        M.read (| verifier |);
                                        Value.StructTuple
                                          "move_core_types::vm_status::StatusCode::BORROWFIELD_TYPE_MISMATCH_ERROR"
                                          [];
                                        M.read (| offset |)
                                      ]
                                    |)
                                  ]
                              |)
                            |)
                          |)
                        |)));
                    fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                  ]
                |) in
              let~ field_handle :=
                M.alloc (|
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "move_binary_format::file_format::CompiledModule",
                      "field_handle_at",
                      []
                    |),
                    [
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| verifier |),
                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                          "module"
                        |)
                      |);
                      M.read (| field_handle_index |)
                    ]
                  |)
                |) in
              let~ struct_def :=
                M.alloc (|
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "move_binary_format::file_format::CompiledModule",
                      "struct_def_at",
                      []
                    |),
                    [
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| verifier |),
                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                          "module"
                        |)
                      |);
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| field_handle |),
                          "move_binary_format::file_format::FieldHandle",
                          "owner"
                        |)
                      |)
                    ]
                  |)
                |) in
              let~ expected_type :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "move_bytecode_verifier::type_safety::materialize_type",
                      []
                    |),
                    [
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| struct_def |),
                          "move_binary_format::file_format::StructDefinition",
                          "struct_handle"
                        |)
                      |);
                      M.read (| type_args |)
                    ]
                  |)
                |) in
              let~ _ :=
                M.match_operator (|
                  operand,
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (M.find_or_pattern (|
                          γ,
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (let γ0_0 :=
                                  M.SubPointer.get_struct_tuple_field (|
                                    γ,
                                    "move_binary_format::file_format::SignatureToken::Reference",
                                    0
                                  |) in
                                let inner := M.copy (| γ0_0 |) in
                                Value.Tuple [ inner ]));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ0_0 :=
                                  M.SubPointer.get_struct_tuple_field (|
                                    γ,
                                    "move_binary_format::file_format::SignatureToken::MutableReference",
                                    0
                                  |) in
                                let inner := M.copy (| γ0_0 |) in
                                Value.Tuple [ inner ]))
                          ],
                          M.closure
                            (fun γ =>
                              ltac:(M.monadic
                                match γ with
                                | [ inner ] =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialEq",
                                            Ty.path
                                              "move_binary_format::file_format::SignatureToken",
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken"
                                            ],
                                            "eq",
                                            []
                                          |),
                                          [ expected_type; M.read (| inner |) ]
                                        |)
                                      |) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (| Value.Tuple [] |)))
                                | _ => M.impossible "wrong number of arguments"
                                end))
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (M.alloc (|
                          M.never_to_any (|
                            M.read (|
                              M.return_ (|
                                Value.StructTuple
                                  "core::result::Result::Err"
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                        "error",
                                        []
                                      |),
                                      [
                                        M.read (| verifier |);
                                        Value.StructTuple
                                          "move_core_types::vm_status::StatusCode::BORROWFIELD_TYPE_MISMATCH_ERROR"
                                          [];
                                        M.read (| offset |)
                                      ]
                                    |)
                                  ]
                              |)
                            |)
                          |)
                        |)))
                  ]
                |) in
              let~ field_def :=
                M.copy (|
                  M.match_operator (|
                    M.alloc (|
                      M.SubPointer.get_struct_record_field (|
                        M.read (| struct_def |),
                        "move_binary_format::file_format::StructDefinition",
                        "field_information"
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "move_binary_format::file_format::StructFieldInformation::Native"
                            |) in
                          M.alloc (|
                            M.never_to_any (|
                              M.read (|
                                M.return_ (|
                                  Value.StructTuple
                                    "core::result::Result::Err"
                                    [
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.path
                                            "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                          "error",
                                          []
                                        |),
                                        [
                                          M.read (| verifier |);
                                          Value.StructTuple
                                            "move_core_types::vm_status::StatusCode::BORROWFIELD_BAD_FIELD_ERROR"
                                            [];
                                          M.read (| offset |)
                                        ]
                                      |)
                                    ]
                                |)
                              |)
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let γ1_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::file_format::StructFieldInformation::Declared",
                              0
                            |) in
                          let fields := M.alloc (| γ1_0 |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "core::ops::index::Index",
                                Ty.apply
                                  (Ty.path "alloc::vec::Vec")
                                  []
                                  [
                                    Ty.path "move_binary_format::file_format::FieldDefinition";
                                    Ty.path "alloc::alloc::Global"
                                  ],
                                [ Ty.path "usize" ],
                                "index",
                                []
                              |),
                              [
                                M.read (| fields |);
                                M.rust_cast
                                  (M.read (|
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| field_handle |),
                                      "move_binary_format::file_format::FieldHandle",
                                      "field"
                                    |)
                                  |))
                              ]
                            |)
                          |)))
                    ]
                  |)
                |) in
              let~ field_type :=
                M.alloc (|
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.apply
                        (Ty.path "alloc::boxed::Box")
                        []
                        [
                          Ty.path "move_binary_format::file_format::SignatureToken";
                          Ty.path "alloc::alloc::Global"
                        ],
                      "new",
                      []
                    |),
                    [
                      M.call_closure (|
                        M.get_function (| "move_bytecode_verifier::type_safety::instantiate", [] |),
                        [
                          M.SubPointer.get_struct_tuple_field (|
                            M.SubPointer.get_struct_record_field (|
                              M.read (| field_def |),
                              "move_binary_format::file_format::FieldDefinition",
                              "signature"
                            |),
                            "move_binary_format::file_format::TypeSignature",
                            0
                          |);
                          M.read (| type_args |)
                        ]
                      |)
                    ]
                  |)
                |) 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_associated_function (|
                            Ty.path "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                            "push",
                            [ impl_Meter__plus___Sized ]
                          |),
                          [
                            M.read (| verifier |);
                            M.read (| meter |);
                            M.read (|
                              M.match_operator (|
                                M.alloc (| Value.Tuple [] |),
                                [
                                  fun γ =>
                                    ltac:(M.monadic
                                      (let γ := M.use mut_ in
                                      let _ :=
                                        M.is_constant_or_break_match (|
                                          M.read (| γ |),
                                          Value.Bool true
                                        |) in
                                      M.alloc (|
                                        Value.StructTuple
                                          "move_binary_format::file_format::SignatureToken::MutableReference"
                                          [ M.read (| field_type |) ]
                                      |)));
                                  fun γ =>
                                    ltac:(M.monadic
                                      (M.alloc (|
                                        Value.StructTuple
                                          "move_binary_format::file_format::SignatureToken::Reference"
                                          [ M.read (| field_type |) ]
                                      |)))
                                ]
                              |)
                            |)
                          ]
                        |)
                      ]
                    |)
                  |),
                  [
                    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.alloc (| Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ] |)
            |)))
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_borrow_field :
    M.IsFunction "move_bytecode_verifier::type_safety::borrow_field" borrow_field.
  
  (*
  fn borrow_loc(
      verifier: &mut TypeSafetyChecker,
      meter: &mut (impl Meter + ?Sized),
      offset: CodeOffset,
      mut_: bool,
      idx: LocalIndex,
  ) -> PartialVMResult<()> {
      let loc_signature = verifier.local_at(idx).clone();
  
      if loc_signature.is_reference() {
          return Err(verifier.error(StatusCode::BORROWLOC_REFERENCE_ERROR, offset));
      }
  
      verifier.push(
          meter,
          if mut_ {
              ST::MutableReference(Box::new(loc_signature))
          } else {
              ST::Reference(Box::new(loc_signature))
          },
      )?;
      Ok(())
  }
  *)
  Definition borrow_loc (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [ impl_Meter__plus___Sized ], [ verifier; meter; offset; mut_; idx ] =>
      ltac:(M.monadic
        (let verifier := M.alloc (| verifier |) in
        let meter := M.alloc (| meter |) in
        let offset := M.alloc (| offset |) in
        let mut_ := M.alloc (| mut_ |) in
        let idx := M.alloc (| idx |) in
        M.catch_return (|
          ltac:(M.monadic
            (M.read (|
              let~ loc_signature :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::clone::Clone",
                      Ty.path "move_binary_format::file_format::SignatureToken",
                      [],
                      "clone",
                      []
                    |),
                    [
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                          "local_at",
                          []
                        |),
                        [ M.read (| verifier |); M.read (| idx |) ]
                      |)
                    ]
                  |)
                |) in
              let~ _ :=
                M.match_operator (|
                  M.alloc (| Value.Tuple [] |),
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ :=
                          M.use
                            (M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::file_format::SignatureToken",
                                  "is_reference",
                                  []
                                |),
                                [ loc_signature ]
                              |)
                            |)) in
                        let _ :=
                          M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                        M.alloc (|
                          M.never_to_any (|
                            M.read (|
                              M.return_ (|
                                Value.StructTuple
                                  "core::result::Result::Err"
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                        "error",
                                        []
                                      |),
                                      [
                                        M.read (| verifier |);
                                        Value.StructTuple
                                          "move_core_types::vm_status::StatusCode::BORROWLOC_REFERENCE_ERROR"
                                          [];
                                        M.read (| offset |)
                                      ]
                                    |)
                                  ]
                              |)
                            |)
                          |)
                        |)));
                    fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                  ]
                |) in
              let~ _ :=
                M.match_operator (|
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "core::ops::try_trait::Try",
                        Ty.apply
                          (Ty.path "core::result::Result")
                          []
                          [ Ty.tuple []; Ty.path "move_binary_format::errors::PartialVMError" ],
                        [],
                        "branch",
                        []
                      |),
                      [
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                            "push",
                            [ impl_Meter__plus___Sized ]
                          |),
                          [
                            M.read (| verifier |);
                            M.read (| meter |);
                            M.read (|
                              M.match_operator (|
                                M.alloc (| Value.Tuple [] |),
                                [
                                  fun γ =>
                                    ltac:(M.monadic
                                      (let γ := M.use mut_ in
                                      let _ :=
                                        M.is_constant_or_break_match (|
                                          M.read (| γ |),
                                          Value.Bool true
                                        |) in
                                      M.alloc (|
                                        Value.StructTuple
                                          "move_binary_format::file_format::SignatureToken::MutableReference"
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.apply
                                                  (Ty.path "alloc::boxed::Box")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_binary_format::file_format::SignatureToken";
                                                    Ty.path "alloc::alloc::Global"
                                                  ],
                                                "new",
                                                []
                                              |),
                                              [ M.read (| loc_signature |) ]
                                            |)
                                          ]
                                      |)));
                                  fun γ =>
                                    ltac:(M.monadic
                                      (M.alloc (|
                                        Value.StructTuple
                                          "move_binary_format::file_format::SignatureToken::Reference"
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.apply
                                                  (Ty.path "alloc::boxed::Box")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_binary_format::file_format::SignatureToken";
                                                    Ty.path "alloc::alloc::Global"
                                                  ],
                                                "new",
                                                []
                                              |),
                                              [ M.read (| loc_signature |) ]
                                            |)
                                          ]
                                      |)))
                                ]
                              |)
                            |)
                          ]
                        |)
                      ]
                    |)
                  |),
                  [
                    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.alloc (| Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ] |)
            |)))
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_borrow_loc :
    M.IsFunction "move_bytecode_verifier::type_safety::borrow_loc" borrow_loc.
  
  (*
  fn borrow_global(
      verifier: &mut TypeSafetyChecker,
      meter: &mut (impl Meter + ?Sized),
      offset: CodeOffset,
      mut_: bool,
      idx: StructDefinitionIndex,
      type_args: &Signature,
  ) -> PartialVMResult<()> {
      // check and consume top of stack
      let operand = safe_unwrap_err!(verifier.stack.pop());
      if operand != ST::Address {
          return Err(verifier.error(StatusCode::BORROWGLOBAL_TYPE_MISMATCH_ERROR, offset));
      }
  
      let struct_def = verifier.module.struct_def_at(idx);
      let struct_type = materialize_type(struct_def.struct_handle, type_args);
      if !verifier.abilities(&struct_type)?.has_key() {
          return Err(verifier.error(StatusCode::BORROWGLOBAL_WITHOUT_KEY_ABILITY, offset));
      }
  
      let struct_type = materialize_type(struct_def.struct_handle, type_args);
      verifier.push(
          meter,
          if mut_ {
              ST::MutableReference(Box::new(struct_type))
          } else {
              ST::Reference(Box::new(struct_type))
          },
      )?;
      Ok(())
  }
  *)
  Definition borrow_global (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [ impl_Meter__plus___Sized ], [ verifier; meter; offset; mut_; idx; type_args ] =>
      ltac:(M.monadic
        (let verifier := M.alloc (| verifier |) in
        let meter := M.alloc (| meter |) in
        let offset := M.alloc (| offset |) in
        let mut_ := M.alloc (| mut_ |) in
        let idx := M.alloc (| idx |) in
        let type_args := M.alloc (| type_args |) in
        M.catch_return (|
          ltac:(M.monadic
            (M.read (|
              let~ operand :=
                M.copy (|
                  M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.apply
                            (Ty.path "move_abstract_stack::AbstractStack")
                            []
                            [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                          "pop",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| verifier |),
                            "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                            "stack"
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Ok",
                              0
                            |) in
                          let x := M.copy (| γ0_0 |) in
                          x));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Err",
                              0
                            |) in
                          let e := M.copy (| γ0_0 |) in
                          let~ err :=
                            M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::errors::PartialVMError",
                                  "with_message",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::errors::PartialVMError",
                                      "new",
                                      []
                                    |),
                                    [
                                      Value.StructTuple
                                        "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                        []
                                    ]
                                  |);
                                  M.call_closure (|
                                    M.get_function (|
                                      "core::hint::must_use",
                                      [ Ty.path "alloc::string::String" ]
                                    |),
                                    [
                                      M.read (|
                                        let~ res :=
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_function (| "alloc::fmt::format", [] |),
                                              [
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "core::fmt::Arguments",
                                                    "new_v1_formatted",
                                                    []
                                                  |),
                                                  [
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.read (|
                                                            Value.String
                                                              "crates/move-bytecode-verifier/src/type_safety.rs:243 "
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Argument",
                                                              "new_display",
                                                              [
                                                                Ty.path
                                                                  "move_abstract_stack::AbsStackError"
                                                              ]
                                                            |),
                                                            [ e ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Placeholder",
                                                              "new",
                                                              []
                                                            |),
                                                            [
                                                              Value.Integer IntegerKind.Usize 0;
                                                              Value.UnicodeChar 32;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Alignment::Unknown"
                                                                [];
                                                              Value.Integer IntegerKind.U32 4;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                [];
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                []
                                                            ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::UnsafeArg",
                                                        "new",
                                                        []
                                                      |),
                                                      []
                                                    |)
                                                  ]
                                                |)
                                              ]
                                            |)
                                          |) in
                                        res
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |) in
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.call_closure (|
                                        M.get_function (| "core::panicking::panic_fmt", [] |),
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "core::fmt::Arguments",
                                              "new_v1",
                                              []
                                            |),
                                            [
                                              M.alloc (|
                                                Value.Array [ M.read (| Value.String "" |) ]
                                              |);
                                              M.alloc (|
                                                Value.Array
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::Argument",
                                                        "new_debug",
                                                        [
                                                          Ty.path
                                                            "move_binary_format::errors::PartialVMError"
                                                        ]
                                                      |),
                                                      [ err ]
                                                    |)
                                                  ]
                                              |)
                                            ]
                                          |)
                                        ]
                                      |)
                                    |)
                                  |)));
                              fun γ =>
                                ltac:(M.monadic
                                  (M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [ M.read (| err |) ]
                                        |)
                                      |)
                                    |)
                                  |)))
                            ]
                          |)))
                    ]
                  |)
                |) in
              let~ _ :=
                M.match_operator (|
                  M.alloc (| Value.Tuple [] |),
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ :=
                          M.use
                            (M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.path "move_binary_format::file_format::SignatureToken",
                                  [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                  "ne",
                                  []
                                |),
                                [
                                  operand;
                                  M.alloc (|
                                    Value.StructTuple
                                      "move_binary_format::file_format::SignatureToken::Address"
                                      []
                                  |)
                                ]
                              |)
                            |)) in
                        let _ :=
                          M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                        M.alloc (|
                          M.never_to_any (|
                            M.read (|
                              M.return_ (|
                                Value.StructTuple
                                  "core::result::Result::Err"
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                        "error",
                                        []
                                      |),
                                      [
                                        M.read (| verifier |);
                                        Value.StructTuple
                                          "move_core_types::vm_status::StatusCode::BORROWGLOBAL_TYPE_MISMATCH_ERROR"
                                          [];
                                        M.read (| offset |)
                                      ]
                                    |)
                                  ]
                              |)
                            |)
                          |)
                        |)));
                    fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                  ]
                |) in
              let~ struct_def :=
                M.alloc (|
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "move_binary_format::file_format::CompiledModule",
                      "struct_def_at",
                      []
                    |),
                    [
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| verifier |),
                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                          "module"
                        |)
                      |);
                      M.read (| idx |)
                    ]
                  |)
                |) in
              let~ struct_type :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "move_bytecode_verifier::type_safety::materialize_type",
                      []
                    |),
                    [
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| struct_def |),
                          "move_binary_format::file_format::StructDefinition",
                          "struct_handle"
                        |)
                      |);
                      M.read (| type_args |)
                    ]
                  |)
                |) in
              let~ _ :=
                M.match_operator (|
                  M.alloc (| Value.Tuple [] |),
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ :=
                          M.use
                            (M.alloc (|
                              UnOp.not (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path "move_binary_format::file_format::AbilitySet",
                                    "has_key",
                                    []
                                  |),
                                  [
                                    M.read (|
                                      M.match_operator (|
                                        M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::ops::try_trait::Try",
                                              Ty.apply
                                                (Ty.path "core::result::Result")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::AbilitySet";
                                                  Ty.path
                                                    "move_binary_format::errors::PartialVMError"
                                                ],
                                              [],
                                              "branch",
                                              []
                                            |),
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path
                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "abilities",
                                                  []
                                                |),
                                                [ M.read (| verifier |); struct_type ]
                                              |)
                                            ]
                                          |)
                                        |),
                                        [
                                          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.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                        M.alloc (|
                          M.never_to_any (|
                            M.read (|
                              M.return_ (|
                                Value.StructTuple
                                  "core::result::Result::Err"
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                        "error",
                                        []
                                      |),
                                      [
                                        M.read (| verifier |);
                                        Value.StructTuple
                                          "move_core_types::vm_status::StatusCode::BORROWGLOBAL_WITHOUT_KEY_ABILITY"
                                          [];
                                        M.read (| offset |)
                                      ]
                                    |)
                                  ]
                              |)
                            |)
                          |)
                        |)));
                    fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                  ]
                |) in
              let~ struct_type :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "move_bytecode_verifier::type_safety::materialize_type",
                      []
                    |),
                    [
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| struct_def |),
                          "move_binary_format::file_format::StructDefinition",
                          "struct_handle"
                        |)
                      |);
                      M.read (| type_args |)
                    ]
                  |)
                |) 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_associated_function (|
                            Ty.path "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                            "push",
                            [ impl_Meter__plus___Sized ]
                          |),
                          [
                            M.read (| verifier |);
                            M.read (| meter |);
                            M.read (|
                              M.match_operator (|
                                M.alloc (| Value.Tuple [] |),
                                [
                                  fun γ =>
                                    ltac:(M.monadic
                                      (let γ := M.use mut_ in
                                      let _ :=
                                        M.is_constant_or_break_match (|
                                          M.read (| γ |),
                                          Value.Bool true
                                        |) in
                                      M.alloc (|
                                        Value.StructTuple
                                          "move_binary_format::file_format::SignatureToken::MutableReference"
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.apply
                                                  (Ty.path "alloc::boxed::Box")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_binary_format::file_format::SignatureToken";
                                                    Ty.path "alloc::alloc::Global"
                                                  ],
                                                "new",
                                                []
                                              |),
                                              [ M.read (| struct_type |) ]
                                            |)
                                          ]
                                      |)));
                                  fun γ =>
                                    ltac:(M.monadic
                                      (M.alloc (|
                                        Value.StructTuple
                                          "move_binary_format::file_format::SignatureToken::Reference"
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.apply
                                                  (Ty.path "alloc::boxed::Box")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_binary_format::file_format::SignatureToken";
                                                    Ty.path "alloc::alloc::Global"
                                                  ],
                                                "new",
                                                []
                                              |),
                                              [ M.read (| struct_type |) ]
                                            |)
                                          ]
                                      |)))
                                ]
                              |)
                            |)
                          ]
                        |)
                      ]
                    |)
                  |),
                  [
                    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.alloc (| Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ] |)
            |)))
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_borrow_global :
    M.IsFunction "move_bytecode_verifier::type_safety::borrow_global" borrow_global.
  
  (*
  fn call(
      verifier: &mut TypeSafetyChecker,
      meter: &mut (impl Meter + ?Sized),
      offset: CodeOffset,
      function_handle: &FunctionHandle,
      type_actuals: &Signature,
  ) -> PartialVMResult<()> {
      let parameters = verifier.module.signature_at(function_handle.parameters);
      for parameter in parameters.0.iter().rev() {
          let arg = safe_unwrap_err!(verifier.stack.pop());
          if (type_actuals.is_empty() && &arg != parameter)
              || (!type_actuals.is_empty() && arg != instantiate(parameter, type_actuals))
          {
              return Err(verifier.error(StatusCode::CALL_TYPE_MISMATCH_ERROR, offset));
          }
      }
      for return_type in &verifier.module.signature_at(function_handle.return_).0 {
          verifier.push(meter, instantiate(return_type, type_actuals))?
      }
      Ok(())
  }
  *)
  Definition call (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [],
        [ impl_Meter__plus___Sized ],
        [ verifier; meter; offset; function_handle; type_actuals ] =>
      ltac:(M.monadic
        (let verifier := M.alloc (| verifier |) in
        let meter := M.alloc (| meter |) in
        let offset := M.alloc (| offset |) in
        let function_handle := M.alloc (| function_handle |) in
        let type_actuals := M.alloc (| type_actuals |) in
        M.catch_return (|
          ltac:(M.monadic
            (M.read (|
              let~ parameters :=
                M.alloc (|
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "move_binary_format::file_format::CompiledModule",
                      "signature_at",
                      []
                    |),
                    [
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| verifier |),
                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                          "module"
                        |)
                      |);
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| function_handle |),
                          "move_binary_format::file_format::FunctionHandle",
                          "parameters"
                        |)
                      |)
                    ]
                  |)
                |) in
              let~ _ :=
                M.use
                  (M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::iter::traits::collect::IntoIterator",
                          Ty.apply
                            (Ty.path "core::iter::adapters::rev::Rev")
                            []
                            [
                              Ty.apply
                                (Ty.path "core::slice::iter::Iter")
                                []
                                [ Ty.path "move_binary_format::file_format::SignatureToken" ]
                            ],
                          [],
                          "into_iter",
                          []
                        |),
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::iter::traits::iterator::Iterator",
                              Ty.apply
                                (Ty.path "core::slice::iter::Iter")
                                []
                                [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                              [],
                              "rev",
                              []
                            |),
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.apply
                                    (Ty.path "slice")
                                    []
                                    [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                  "iter",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::ops::deref::Deref",
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::file_format::SignatureToken";
                                          Ty.path "alloc::alloc::Global"
                                        ],
                                      [],
                                      "deref",
                                      []
                                    |),
                                    [
                                      M.SubPointer.get_struct_tuple_field (|
                                        M.read (| parameters |),
                                        "move_binary_format::file_format::Signature",
                                        0
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            ]
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let iter := M.copy (| γ |) in
                          M.loop (|
                            ltac:(M.monadic
                              (let~ _ :=
                                M.match_operator (|
                                  M.alloc (|
                                    M.call_closure (|
                                      M.get_trait_method (|
                                        "core::iter::traits::iterator::Iterator",
                                        Ty.apply
                                          (Ty.path "core::iter::adapters::rev::Rev")
                                          []
                                          [
                                            Ty.apply
                                              (Ty.path "core::slice::iter::Iter")
                                              []
                                              [
                                                Ty.path
                                                  "move_binary_format::file_format::SignatureToken"
                                              ]
                                          ],
                                        [],
                                        "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 parameter := M.copy (| γ0_0 |) in
                                        let~ arg :=
                                          M.copy (|
                                            M.match_operator (|
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.apply
                                                      (Ty.path "move_abstract_stack::AbstractStack")
                                                      []
                                                      [
                                                        Ty.path
                                                          "move_binary_format::file_format::SignatureToken"
                                                      ],
                                                    "pop",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_struct_record_field (|
                                                      M.read (| verifier |),
                                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                      "stack"
                                                    |)
                                                  ]
                                                |)
                                              |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ0_0 :=
                                                      M.SubPointer.get_struct_tuple_field (|
                                                        γ,
                                                        "core::result::Result::Ok",
                                                        0
                                                      |) in
                                                    let x := M.copy (| γ0_0 |) in
                                                    x));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ0_0 :=
                                                      M.SubPointer.get_struct_tuple_field (|
                                                        γ,
                                                        "core::result::Result::Err",
                                                        0
                                                      |) in
                                                    let e := M.copy (| γ0_0 |) in
                                                    let~ err :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_binary_format::errors::PartialVMError",
                                                            "with_message",
                                                            []
                                                          |),
                                                          [
                                                            M.call_closure (|
                                                              M.get_associated_function (|
                                                                Ty.path
                                                                  "move_binary_format::errors::PartialVMError",
                                                                "new",
                                                                []
                                                              |),
                                                              [
                                                                Value.StructTuple
                                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                                  []
                                                              ]
                                                            |);
                                                            M.call_closure (|
                                                              M.get_function (|
                                                                "core::hint::must_use",
                                                                [ Ty.path "alloc::string::String" ]
                                                              |),
                                                              [
                                                                M.read (|
                                                                  let~ res :=
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_function (|
                                                                          "alloc::fmt::format",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::Arguments",
                                                                              "new_v1_formatted",
                                                                              []
                                                                            |),
                                                                            [
                                                                              M.alloc (|
                                                                                Value.Array
                                                                                  [
                                                                                    M.read (|
                                                                                      Value.String
                                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:275 "
                                                                                    |)
                                                                                  ]
                                                                              |);
                                                                              M.alloc (|
                                                                                Value.Array
                                                                                  [
                                                                                    M.call_closure (|
                                                                                      M.get_associated_function (|
                                                                                        Ty.path
                                                                                          "core::fmt::rt::Argument",
                                                                                        "new_display",
                                                                                        [
                                                                                          Ty.path
                                                                                            "move_abstract_stack::AbsStackError"
                                                                                        ]
                                                                                      |),
                                                                                      [ e ]
                                                                                    |)
                                                                                  ]
                                                                              |);
                                                                              M.alloc (|
                                                                                Value.Array
                                                                                  [
                                                                                    M.call_closure (|
                                                                                      M.get_associated_function (|
                                                                                        Ty.path
                                                                                          "core::fmt::rt::Placeholder",
                                                                                        "new",
                                                                                        []
                                                                                      |),
                                                                                      [
                                                                                        Value.Integer
                                                                                          IntegerKind.Usize
                                                                                          0;
                                                                                        Value.UnicodeChar
                                                                                          32;
                                                                                        Value.StructTuple
                                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                                          [];
                                                                                        Value.Integer
                                                                                          IntegerKind.U32
                                                                                          4;
                                                                                        Value.StructTuple
                                                                                          "core::fmt::rt::Count::Implied"
                                                                                          [];
                                                                                        Value.StructTuple
                                                                                          "core::fmt::rt::Count::Implied"
                                                                                          []
                                                                                      ]
                                                                                    |)
                                                                                  ]
                                                                              |);
                                                                              M.call_closure (|
                                                                                M.get_associated_function (|
                                                                                  Ty.path
                                                                                    "core::fmt::rt::UnsafeArg",
                                                                                  "new",
                                                                                  []
                                                                                |),
                                                                                []
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |) in
                                                                  res
                                                                |)
                                                              ]
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (| Value.Bool true |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.never_to_any (|
                                                                M.call_closure (|
                                                                  M.get_function (|
                                                                    "core::panicking::panic_fmt",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::Arguments",
                                                                        "new_v1",
                                                                        []
                                                                      |),
                                                                      [
                                                                        M.alloc (|
                                                                          Value.Array
                                                                            [
                                                                              M.read (|
                                                                                Value.String ""
                                                                              |)
                                                                            ]
                                                                        |);
                                                                        M.alloc (|
                                                                          Value.Array
                                                                            [
                                                                              M.call_closure (|
                                                                                M.get_associated_function (|
                                                                                  Ty.path
                                                                                    "core::fmt::rt::Argument",
                                                                                  "new_debug",
                                                                                  [
                                                                                    Ty.path
                                                                                      "move_binary_format::errors::PartialVMError"
                                                                                  ]
                                                                                |),
                                                                                [ err ]
                                                                              |)
                                                                            ]
                                                                        |)
                                                                      ]
                                                                    |)
                                                                  ]
                                                                |)
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (M.alloc (|
                                                              M.never_to_any (|
                                                                M.read (|
                                                                  M.return_ (|
                                                                    Value.StructTuple
                                                                      "core::result::Result::Err"
                                                                      [ M.read (| err |) ]
                                                                  |)
                                                                |)
                                                              |)
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)
                                          |) in
                                        M.match_operator (|
                                          M.alloc (| Value.Tuple [] |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ :=
                                                  M.use
                                                    (M.alloc (|
                                                      LogicalOp.or (|
                                                        LogicalOp.and (|
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path
                                                                "move_binary_format::file_format::Signature",
                                                              "is_empty",
                                                              []
                                                            |),
                                                            [ M.read (| type_actuals |) ]
                                                          |),
                                                          ltac:(M.monadic
                                                            (M.call_closure (|
                                                              M.get_trait_method (|
                                                                "core::cmp::PartialEq",
                                                                Ty.apply
                                                                  (Ty.path "&")
                                                                  []
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::file_format::SignatureToken"
                                                                  ],
                                                                [
                                                                  Ty.apply
                                                                    (Ty.path "&")
                                                                    []
                                                                    [
                                                                      Ty.path
                                                                        "move_binary_format::file_format::SignatureToken"
                                                                    ]
                                                                ],
                                                                "ne",
                                                                []
                                                              |),
                                                              [ M.alloc (| arg |); parameter ]
                                                            |)))
                                                        |),
                                                        ltac:(M.monadic
                                                          (LogicalOp.and (|
                                                            UnOp.not (|
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "move_binary_format::file_format::Signature",
                                                                  "is_empty",
                                                                  []
                                                                |),
                                                                [ M.read (| type_actuals |) ]
                                                              |)
                                                            |),
                                                            ltac:(M.monadic
                                                              (M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.path
                                                                    "move_binary_format::file_format::SignatureToken",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::file_format::SignatureToken"
                                                                  ],
                                                                  "ne",
                                                                  []
                                                                |),
                                                                [
                                                                  arg;
                                                                  M.alloc (|
                                                                    M.call_closure (|
                                                                      M.get_function (|
                                                                        "move_bytecode_verifier::type_safety::instantiate",
                                                                        []
                                                                      |),
                                                                      [
                                                                        M.read (| parameter |);
                                                                        M.read (| type_actuals |)
                                                                      ]
                                                                    |)
                                                                  |)
                                                                ]
                                                              |)))
                                                          |)))
                                                      |)
                                                    |)) in
                                                let _ :=
                                                  M.is_constant_or_break_match (|
                                                    M.read (| γ |),
                                                    Value.Bool true
                                                  |) in
                                                M.alloc (|
                                                  M.never_to_any (|
                                                    M.read (|
                                                      M.return_ (|
                                                        Value.StructTuple
                                                          "core::result::Result::Err"
                                                          [
                                                            M.call_closure (|
                                                              M.get_associated_function (|
                                                                Ty.path
                                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                                "error",
                                                                []
                                                              |),
                                                              [
                                                                M.read (| verifier |);
                                                                Value.StructTuple
                                                                  "move_core_types::vm_status::StatusCode::CALL_TYPE_MISMATCH_ERROR"
                                                                  [];
                                                                M.read (| offset |)
                                                              ]
                                                            |)
                                                          ]
                                                      |)
                                                    |)
                                                  |)
                                                |)));
                                            fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                          ]
                                        |)))
                                  ]
                                |) in
                              M.alloc (| Value.Tuple [] |)))
                          |)))
                    ]
                  |)) 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 "move_binary_format::file_format::SignatureToken";
                                  Ty.path "alloc::alloc::Global"
                                ]
                            ],
                          [],
                          "into_iter",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_tuple_field (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "signature_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| function_handle |),
                                    "move_binary_format::file_format::FunctionHandle",
                                    "return_"
                                  |)
                                |)
                              ]
                            |),
                            "move_binary_format::file_format::Signature",
                            0
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let iter := M.copy (| γ |) in
                          M.loop (|
                            ltac:(M.monadic
                              (let~ _ :=
                                M.match_operator (|
                                  M.alloc (|
                                    M.call_closure (|
                                      M.get_trait_method (|
                                        "core::iter::traits::iterator::Iterator",
                                        Ty.apply
                                          (Ty.path "core::slice::iter::Iter")
                                          []
                                          [
                                            Ty.path
                                              "move_binary_format::file_format::SignatureToken"
                                          ],
                                        [],
                                        "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 return_type := M.copy (| γ0_0 |) 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_associated_function (|
                                                    Ty.path
                                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                    "push",
                                                    [ impl_Meter__plus___Sized ]
                                                  |),
                                                  [
                                                    M.read (| verifier |);
                                                    M.read (| meter |);
                                                    M.call_closure (|
                                                      M.get_function (|
                                                        "move_bytecode_verifier::type_safety::instantiate",
                                                        []
                                                      |),
                                                      [
                                                        M.read (| return_type |);
                                                        M.read (| type_actuals |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              ]
                                            |)
                                          |),
                                          [
                                            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.alloc (| Value.Tuple [] |)))
                          |)))
                    ]
                  |)) in
              M.alloc (| Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ] |)
            |)))
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_call : M.IsFunction "move_bytecode_verifier::type_safety::call" call.
  
  (*
  fn type_fields_signature(
      verifier: &mut TypeSafetyChecker,
      _meter: &mut (impl Meter + ?Sized), // TODO: metering
      offset: CodeOffset,
      struct_def: &StructDefinition,
      type_args: &Signature,
  ) -> PartialVMResult<Signature> {
      match &struct_def.field_information {
          StructFieldInformation::Native => {
              // TODO: this is more of "unreachable"
              Err(verifier.error(StatusCode::PACK_TYPE_MISMATCH_ERROR, offset))
          }
          StructFieldInformation::Declared(fields) => {
              let mut field_sig = vec![];
              for field_def in fields.iter() {
                  field_sig.push(instantiate(&field_def.signature.0, type_args));
              }
              Ok(Signature(field_sig))
          }
      }
  }
  *)
  Definition type_fields_signature (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [ impl_Meter__plus___Sized ], [ verifier; _meter; offset; struct_def; type_args ] =>
      ltac:(M.monadic
        (let verifier := M.alloc (| verifier |) in
        let _meter := M.alloc (| _meter |) in
        let offset := M.alloc (| offset |) in
        let struct_def := M.alloc (| struct_def |) in
        let type_args := M.alloc (| type_args |) in
        M.read (|
          M.match_operator (|
            M.alloc (|
              M.SubPointer.get_struct_record_field (|
                M.read (| struct_def |),
                "move_binary_format::file_format::StructDefinition",
                "field_information"
              |)
            |),
            [
              fun γ =>
                ltac:(M.monadic
                  (let γ := M.read (| γ |) in
                  let _ :=
                    M.is_struct_tuple (|
                      γ,
                      "move_binary_format::file_format::StructFieldInformation::Native"
                    |) in
                  M.alloc (|
                    Value.StructTuple
                      "core::result::Result::Err"
                      [
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                            "error",
                            []
                          |),
                          [
                            M.read (| verifier |);
                            Value.StructTuple
                              "move_core_types::vm_status::StatusCode::PACK_TYPE_MISMATCH_ERROR"
                              [];
                            M.read (| offset |)
                          ]
                        |)
                      ]
                  |)));
              fun γ =>
                ltac:(M.monadic
                  (let γ := M.read (| γ |) in
                  let γ1_0 :=
                    M.SubPointer.get_struct_tuple_field (|
                      γ,
                      "move_binary_format::file_format::StructFieldInformation::Declared",
                      0
                    |) in
                  let fields := M.alloc (| γ1_0 |) in
                  let~ field_sig :=
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.apply
                            (Ty.path "alloc::vec::Vec")
                            []
                            [
                              Ty.path "move_binary_format::file_format::SignatureToken";
                              Ty.path "alloc::alloc::Global"
                            ],
                          "new",
                          []
                        |),
                        []
                      |)
                    |) in
                  let~ _ :=
                    M.use
                      (M.match_operator (|
                        M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::iter::traits::collect::IntoIterator",
                              Ty.apply
                                (Ty.path "core::slice::iter::Iter")
                                []
                                [ Ty.path "move_binary_format::file_format::FieldDefinition" ],
                              [],
                              "into_iter",
                              []
                            |),
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.apply
                                    (Ty.path "slice")
                                    []
                                    [ Ty.path "move_binary_format::file_format::FieldDefinition" ],
                                  "iter",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::ops::deref::Deref",
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path
                                            "move_binary_format::file_format::FieldDefinition";
                                          Ty.path "alloc::alloc::Global"
                                        ],
                                      [],
                                      "deref",
                                      []
                                    |),
                                    [ M.read (| fields |) ]
                                  |)
                                ]
                              |)
                            ]
                          |)
                        |),
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let iter := M.copy (| γ |) in
                              M.loop (|
                                ltac:(M.monadic
                                  (let~ _ :=
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::iter::traits::iterator::Iterator",
                                            Ty.apply
                                              (Ty.path "core::slice::iter::Iter")
                                              []
                                              [
                                                Ty.path
                                                  "move_binary_format::file_format::FieldDefinition"
                                              ],
                                            [],
                                            "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 field_def := M.copy (| γ0_0 |) in
                                            let~ _ :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.apply
                                                      (Ty.path "alloc::vec::Vec")
                                                      []
                                                      [
                                                        Ty.path
                                                          "move_binary_format::file_format::SignatureToken";
                                                        Ty.path "alloc::alloc::Global"
                                                      ],
                                                    "push",
                                                    []
                                                  |),
                                                  [
                                                    field_sig;
                                                    M.call_closure (|
                                                      M.get_function (|
                                                        "move_bytecode_verifier::type_safety::instantiate",
                                                        []
                                                      |),
                                                      [
                                                        M.SubPointer.get_struct_tuple_field (|
                                                          M.SubPointer.get_struct_record_field (|
                                                            M.read (| field_def |),
                                                            "move_binary_format::file_format::FieldDefinition",
                                                            "signature"
                                                          |),
                                                          "move_binary_format::file_format::TypeSignature",
                                                          0
                                                        |);
                                                        M.read (| type_args |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.alloc (| Value.Tuple [] |)))
                                      ]
                                    |) in
                                  M.alloc (| Value.Tuple [] |)))
                              |)))
                        ]
                      |)) in
                  M.alloc (|
                    Value.StructTuple
                      "core::result::Result::Ok"
                      [
                        Value.StructTuple
                          "move_binary_format::file_format::Signature"
                          [ M.read (| field_sig |) ]
                      ]
                  |)))
            ]
          |)
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_type_fields_signature :
    M.IsFunction "move_bytecode_verifier::type_safety::type_fields_signature" type_fields_signature.
  
  (*
  fn pack(
      verifier: &mut TypeSafetyChecker,
      meter: &mut (impl Meter + ?Sized),
      offset: CodeOffset,
      struct_def: &StructDefinition,
      type_args: &Signature,
  ) -> PartialVMResult<()> {
      let struct_type = materialize_type(struct_def.struct_handle, type_args);
      let field_sig = type_fields_signature(verifier, meter, offset, struct_def, type_args)?;
      for sig in field_sig.0.iter().rev() {
          let arg = safe_unwrap_err!(verifier.stack.pop());
          if &arg != sig {
              return Err(verifier.error(StatusCode::PACK_TYPE_MISMATCH_ERROR, offset));
          }
      }
  
      verifier.push(meter, struct_type)?;
      Ok(())
  }
  *)
  Definition pack (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [ impl_Meter__plus___Sized ], [ verifier; meter; offset; struct_def; type_args ] =>
      ltac:(M.monadic
        (let verifier := M.alloc (| verifier |) in
        let meter := M.alloc (| meter |) in
        let offset := M.alloc (| offset |) in
        let struct_def := M.alloc (| struct_def |) in
        let type_args := M.alloc (| type_args |) in
        M.catch_return (|
          ltac:(M.monadic
            (M.read (|
              let~ struct_type :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "move_bytecode_verifier::type_safety::materialize_type",
                      []
                    |),
                    [
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| struct_def |),
                          "move_binary_format::file_format::StructDefinition",
                          "struct_handle"
                        |)
                      |);
                      M.read (| type_args |)
                    ]
                  |)
                |) in
              let~ field_sig :=
                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_binary_format::file_format::Signature";
                              Ty.path "move_binary_format::errors::PartialVMError"
                            ],
                          [],
                          "branch",
                          []
                        |),
                        [
                          M.call_closure (|
                            M.get_function (|
                              "move_bytecode_verifier::type_safety::type_fields_signature",
                              [ impl_Meter__plus___Sized ]
                            |),
                            [
                              M.read (| verifier |);
                              M.read (| meter |);
                              M.read (| offset |);
                              M.read (| struct_def |);
                              M.read (| type_args |)
                            ]
                          |)
                        ]
                      |)
                    |),
                    [
                      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.use
                  (M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::iter::traits::collect::IntoIterator",
                          Ty.apply
                            (Ty.path "core::iter::adapters::rev::Rev")
                            []
                            [
                              Ty.apply
                                (Ty.path "core::slice::iter::Iter")
                                []
                                [ Ty.path "move_binary_format::file_format::SignatureToken" ]
                            ],
                          [],
                          "into_iter",
                          []
                        |),
                        [
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::iter::traits::iterator::Iterator",
                              Ty.apply
                                (Ty.path "core::slice::iter::Iter")
                                []
                                [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                              [],
                              "rev",
                              []
                            |),
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.apply
                                    (Ty.path "slice")
                                    []
                                    [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                  "iter",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::ops::deref::Deref",
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "move_binary_format::file_format::SignatureToken";
                                          Ty.path "alloc::alloc::Global"
                                        ],
                                      [],
                                      "deref",
                                      []
                                    |),
                                    [
                                      M.SubPointer.get_struct_tuple_field (|
                                        field_sig,
                                        "move_binary_format::file_format::Signature",
                                        0
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            ]
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let iter := M.copy (| γ |) in
                          M.loop (|
                            ltac:(M.monadic
                              (let~ _ :=
                                M.match_operator (|
                                  M.alloc (|
                                    M.call_closure (|
                                      M.get_trait_method (|
                                        "core::iter::traits::iterator::Iterator",
                                        Ty.apply
                                          (Ty.path "core::iter::adapters::rev::Rev")
                                          []
                                          [
                                            Ty.apply
                                              (Ty.path "core::slice::iter::Iter")
                                              []
                                              [
                                                Ty.path
                                                  "move_binary_format::file_format::SignatureToken"
                                              ]
                                          ],
                                        [],
                                        "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 sig := M.copy (| γ0_0 |) in
                                        let~ arg :=
                                          M.copy (|
                                            M.match_operator (|
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.apply
                                                      (Ty.path "move_abstract_stack::AbstractStack")
                                                      []
                                                      [
                                                        Ty.path
                                                          "move_binary_format::file_format::SignatureToken"
                                                      ],
                                                    "pop",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_struct_record_field (|
                                                      M.read (| verifier |),
                                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                      "stack"
                                                    |)
                                                  ]
                                                |)
                                              |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ0_0 :=
                                                      M.SubPointer.get_struct_tuple_field (|
                                                        γ,
                                                        "core::result::Result::Ok",
                                                        0
                                                      |) in
                                                    let x := M.copy (| γ0_0 |) in
                                                    x));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ0_0 :=
                                                      M.SubPointer.get_struct_tuple_field (|
                                                        γ,
                                                        "core::result::Result::Err",
                                                        0
                                                      |) in
                                                    let e := M.copy (| γ0_0 |) in
                                                    let~ err :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_binary_format::errors::PartialVMError",
                                                            "with_message",
                                                            []
                                                          |),
                                                          [
                                                            M.call_closure (|
                                                              M.get_associated_function (|
                                                                Ty.path
                                                                  "move_binary_format::errors::PartialVMError",
                                                                "new",
                                                                []
                                                              |),
                                                              [
                                                                Value.StructTuple
                                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                                  []
                                                              ]
                                                            |);
                                                            M.call_closure (|
                                                              M.get_function (|
                                                                "core::hint::must_use",
                                                                [ Ty.path "alloc::string::String" ]
                                                              |),
                                                              [
                                                                M.read (|
                                                                  let~ res :=
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_function (|
                                                                          "alloc::fmt::format",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::Arguments",
                                                                              "new_v1_formatted",
                                                                              []
                                                                            |),
                                                                            [
                                                                              M.alloc (|
                                                                                Value.Array
                                                                                  [
                                                                                    M.read (|
                                                                                      Value.String
                                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:320 "
                                                                                    |)
                                                                                  ]
                                                                              |);
                                                                              M.alloc (|
                                                                                Value.Array
                                                                                  [
                                                                                    M.call_closure (|
                                                                                      M.get_associated_function (|
                                                                                        Ty.path
                                                                                          "core::fmt::rt::Argument",
                                                                                        "new_display",
                                                                                        [
                                                                                          Ty.path
                                                                                            "move_abstract_stack::AbsStackError"
                                                                                        ]
                                                                                      |),
                                                                                      [ e ]
                                                                                    |)
                                                                                  ]
                                                                              |);
                                                                              M.alloc (|
                                                                                Value.Array
                                                                                  [
                                                                                    M.call_closure (|
                                                                                      M.get_associated_function (|
                                                                                        Ty.path
                                                                                          "core::fmt::rt::Placeholder",
                                                                                        "new",
                                                                                        []
                                                                                      |),
                                                                                      [
                                                                                        Value.Integer
                                                                                          IntegerKind.Usize
                                                                                          0;
                                                                                        Value.UnicodeChar
                                                                                          32;
                                                                                        Value.StructTuple
                                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                                          [];
                                                                                        Value.Integer
                                                                                          IntegerKind.U32
                                                                                          4;
                                                                                        Value.StructTuple
                                                                                          "core::fmt::rt::Count::Implied"
                                                                                          [];
                                                                                        Value.StructTuple
                                                                                          "core::fmt::rt::Count::Implied"
                                                                                          []
                                                                                      ]
                                                                                    |)
                                                                                  ]
                                                                              |);
                                                                              M.call_closure (|
                                                                                M.get_associated_function (|
                                                                                  Ty.path
                                                                                    "core::fmt::rt::UnsafeArg",
                                                                                  "new",
                                                                                  []
                                                                                |),
                                                                                []
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |) in
                                                                  res
                                                                |)
                                                              ]
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (| Value.Bool true |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.never_to_any (|
                                                                M.call_closure (|
                                                                  M.get_function (|
                                                                    "core::panicking::panic_fmt",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::Arguments",
                                                                        "new_v1",
                                                                        []
                                                                      |),
                                                                      [
                                                                        M.alloc (|
                                                                          Value.Array
                                                                            [
                                                                              M.read (|
                                                                                Value.String ""
                                                                              |)
                                                                            ]
                                                                        |);
                                                                        M.alloc (|
                                                                          Value.Array
                                                                            [
                                                                              M.call_closure (|
                                                                                M.get_associated_function (|
                                                                                  Ty.path
                                                                                    "core::fmt::rt::Argument",
                                                                                  "new_debug",
                                                                                  [
                                                                                    Ty.path
                                                                                      "move_binary_format::errors::PartialVMError"
                                                                                  ]
                                                                                |),
                                                                                [ err ]
                                                                              |)
                                                                            ]
                                                                        |)
                                                                      ]
                                                                    |)
                                                                  ]
                                                                |)
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (M.alloc (|
                                                              M.never_to_any (|
                                                                M.read (|
                                                                  M.return_ (|
                                                                    Value.StructTuple
                                                                      "core::result::Result::Err"
                                                                      [ M.read (| err |) ]
                                                                  |)
                                                                |)
                                                              |)
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)
                                          |) in
                                        M.match_operator (|
                                          M.alloc (| Value.Tuple [] |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ :=
                                                  M.use
                                                    (M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "&")
                                                            []
                                                            [
                                                              Ty.path
                                                                "move_binary_format::file_format::SignatureToken"
                                                            ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "&")
                                                              []
                                                              [
                                                                Ty.path
                                                                  "move_binary_format::file_format::SignatureToken"
                                                              ]
                                                          ],
                                                          "ne",
                                                          []
                                                        |),
                                                        [ M.alloc (| arg |); sig ]
                                                      |)
                                                    |)) in
                                                let _ :=
                                                  M.is_constant_or_break_match (|
                                                    M.read (| γ |),
                                                    Value.Bool true
                                                  |) in
                                                M.alloc (|
                                                  M.never_to_any (|
                                                    M.read (|
                                                      M.return_ (|
                                                        Value.StructTuple
                                                          "core::result::Result::Err"
                                                          [
                                                            M.call_closure (|
                                                              M.get_associated_function (|
                                                                Ty.path
                                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                                "error",
                                                                []
                                                              |),
                                                              [
                                                                M.read (| verifier |);
                                                                Value.StructTuple
                                                                  "move_core_types::vm_status::StatusCode::PACK_TYPE_MISMATCH_ERROR"
                                                                  [];
                                                                M.read (| offset |)
                                                              ]
                                                            |)
                                                          ]
                                                      |)
                                                    |)
                                                  |)
                                                |)));
                                            fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                          ]
                                        |)))
                                  ]
                                |) in
                              M.alloc (| Value.Tuple [] |)))
                          |)))
                    ]
                  |)) in
              let~ _ :=
                M.match_operator (|
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "core::ops::try_trait::Try",
                        Ty.apply
                          (Ty.path "core::result::Result")
                          []
                          [ Ty.tuple []; Ty.path "move_binary_format::errors::PartialVMError" ],
                        [],
                        "branch",
                        []
                      |),
                      [
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                            "push",
                            [ impl_Meter__plus___Sized ]
                          |),
                          [ M.read (| verifier |); M.read (| meter |); M.read (| struct_type |) ]
                        |)
                      ]
                    |)
                  |),
                  [
                    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.alloc (| Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ] |)
            |)))
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_pack : M.IsFunction "move_bytecode_verifier::type_safety::pack" pack.
  
  (*
  fn unpack(
      verifier: &mut TypeSafetyChecker,
      meter: &mut (impl Meter + ?Sized),
      offset: CodeOffset,
      struct_def: &StructDefinition,
      type_args: &Signature,
  ) -> PartialVMResult<()> {
      let struct_type = materialize_type(struct_def.struct_handle, type_args);
  
      // Pop an abstract value from the stack and check if its type is equal to the one
      // declared.
      let arg = safe_unwrap_err!(verifier.stack.pop());
      if arg != struct_type {
          return Err(verifier.error(StatusCode::UNPACK_TYPE_MISMATCH_ERROR, offset));
      }
  
      let field_sig = type_fields_signature(verifier, meter, offset, struct_def, type_args)?;
      for sig in field_sig.0 {
          verifier.push(meter, sig)?
      }
      Ok(())
  }
  *)
  Definition unpack (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [ impl_Meter__plus___Sized ], [ verifier; meter; offset; struct_def; type_args ] =>
      ltac:(M.monadic
        (let verifier := M.alloc (| verifier |) in
        let meter := M.alloc (| meter |) in
        let offset := M.alloc (| offset |) in
        let struct_def := M.alloc (| struct_def |) in
        let type_args := M.alloc (| type_args |) in
        M.catch_return (|
          ltac:(M.monadic
            (M.read (|
              let~ struct_type :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "move_bytecode_verifier::type_safety::materialize_type",
                      []
                    |),
                    [
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| struct_def |),
                          "move_binary_format::file_format::StructDefinition",
                          "struct_handle"
                        |)
                      |);
                      M.read (| type_args |)
                    ]
                  |)
                |) in
              let~ arg :=
                M.copy (|
                  M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.apply
                            (Ty.path "move_abstract_stack::AbstractStack")
                            []
                            [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                          "pop",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| verifier |),
                            "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                            "stack"
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Ok",
                              0
                            |) in
                          let x := M.copy (| γ0_0 |) in
                          x));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Err",
                              0
                            |) in
                          let e := M.copy (| γ0_0 |) in
                          let~ err :=
                            M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::errors::PartialVMError",
                                  "with_message",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::errors::PartialVMError",
                                      "new",
                                      []
                                    |),
                                    [
                                      Value.StructTuple
                                        "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                        []
                                    ]
                                  |);
                                  M.call_closure (|
                                    M.get_function (|
                                      "core::hint::must_use",
                                      [ Ty.path "alloc::string::String" ]
                                    |),
                                    [
                                      M.read (|
                                        let~ res :=
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_function (| "alloc::fmt::format", [] |),
                                              [
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "core::fmt::Arguments",
                                                    "new_v1_formatted",
                                                    []
                                                  |),
                                                  [
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.read (|
                                                            Value.String
                                                              "crates/move-bytecode-verifier/src/type_safety.rs:341 "
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Argument",
                                                              "new_display",
                                                              [
                                                                Ty.path
                                                                  "move_abstract_stack::AbsStackError"
                                                              ]
                                                            |),
                                                            [ e ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Placeholder",
                                                              "new",
                                                              []
                                                            |),
                                                            [
                                                              Value.Integer IntegerKind.Usize 0;
                                                              Value.UnicodeChar 32;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Alignment::Unknown"
                                                                [];
                                                              Value.Integer IntegerKind.U32 4;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                [];
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                []
                                                            ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::UnsafeArg",
                                                        "new",
                                                        []
                                                      |),
                                                      []
                                                    |)
                                                  ]
                                                |)
                                              ]
                                            |)
                                          |) in
                                        res
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |) in
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.call_closure (|
                                        M.get_function (| "core::panicking::panic_fmt", [] |),
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "core::fmt::Arguments",
                                              "new_v1",
                                              []
                                            |),
                                            [
                                              M.alloc (|
                                                Value.Array [ M.read (| Value.String "" |) ]
                                              |);
                                              M.alloc (|
                                                Value.Array
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::Argument",
                                                        "new_debug",
                                                        [
                                                          Ty.path
                                                            "move_binary_format::errors::PartialVMError"
                                                        ]
                                                      |),
                                                      [ err ]
                                                    |)
                                                  ]
                                              |)
                                            ]
                                          |)
                                        ]
                                      |)
                                    |)
                                  |)));
                              fun γ =>
                                ltac:(M.monadic
                                  (M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [ M.read (| err |) ]
                                        |)
                                      |)
                                    |)
                                  |)))
                            ]
                          |)))
                    ]
                  |)
                |) in
              let~ _ :=
                M.match_operator (|
                  M.alloc (| Value.Tuple [] |),
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ :=
                          M.use
                            (M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.path "move_binary_format::file_format::SignatureToken",
                                  [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                  "ne",
                                  []
                                |),
                                [ arg; struct_type ]
                              |)
                            |)) in
                        let _ :=
                          M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                        M.alloc (|
                          M.never_to_any (|
                            M.read (|
                              M.return_ (|
                                Value.StructTuple
                                  "core::result::Result::Err"
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                        "error",
                                        []
                                      |),
                                      [
                                        M.read (| verifier |);
                                        Value.StructTuple
                                          "move_core_types::vm_status::StatusCode::UNPACK_TYPE_MISMATCH_ERROR"
                                          [];
                                        M.read (| offset |)
                                      ]
                                    |)
                                  ]
                              |)
                            |)
                          |)
                        |)));
                    fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                  ]
                |) in
              let~ field_sig :=
                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_binary_format::file_format::Signature";
                              Ty.path "move_binary_format::errors::PartialVMError"
                            ],
                          [],
                          "branch",
                          []
                        |),
                        [
                          M.call_closure (|
                            M.get_function (|
                              "move_bytecode_verifier::type_safety::type_fields_signature",
                              [ impl_Meter__plus___Sized ]
                            |),
                            [
                              M.read (| verifier |);
                              M.read (| meter |);
                              M.read (| offset |);
                              M.read (| struct_def |);
                              M.read (| type_args |)
                            ]
                          |)
                        ]
                      |)
                    |),
                    [
                      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.use
                  (M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::iter::traits::collect::IntoIterator",
                          Ty.apply
                            (Ty.path "alloc::vec::Vec")
                            []
                            [
                              Ty.path "move_binary_format::file_format::SignatureToken";
                              Ty.path "alloc::alloc::Global"
                            ],
                          [],
                          "into_iter",
                          []
                        |),
                        [
                          M.read (|
                            M.SubPointer.get_struct_tuple_field (|
                              field_sig,
                              "move_binary_format::file_format::Signature",
                              0
                            |)
                          |)
                        ]
                      |)
                    |),
                    [
                      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::vec::into_iter::IntoIter")
                                          []
                                          [
                                            Ty.path
                                              "move_binary_format::file_format::SignatureToken";
                                            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 sig := M.copy (| γ0_0 |) 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_associated_function (|
                                                    Ty.path
                                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                    "push",
                                                    [ impl_Meter__plus___Sized ]
                                                  |),
                                                  [
                                                    M.read (| verifier |);
                                                    M.read (| meter |);
                                                    M.read (| sig |)
                                                  ]
                                                |)
                                              ]
                                            |)
                                          |),
                                          [
                                            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.alloc (| Value.Tuple [] |)))
                          |)))
                    ]
                  |)) in
              M.alloc (| Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ] |)
            |)))
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_unpack : M.IsFunction "move_bytecode_verifier::type_safety::unpack" unpack.
  
  (*
  fn exists(
      verifier: &mut TypeSafetyChecker,
      meter: &mut (impl Meter + ?Sized),
      offset: CodeOffset,
      struct_def: &StructDefinition,
      type_args: &Signature,
  ) -> PartialVMResult<()> {
      let struct_type = materialize_type(struct_def.struct_handle, type_args);
      if !verifier.abilities(&struct_type)?.has_key() {
          return Err(verifier.error(
              StatusCode::EXISTS_WITHOUT_KEY_ABILITY_OR_BAD_ARGUMENT,
              offset,
          ));
      }
  
      let operand = safe_unwrap_err!(verifier.stack.pop());
      if operand != ST::Address {
          // TODO better error here
          return Err(verifier.error(
              StatusCode::EXISTS_WITHOUT_KEY_ABILITY_OR_BAD_ARGUMENT,
              offset,
          ));
      }
  
      verifier.push(meter, ST::Bool)?;
      Ok(())
  }
  *)
  Definition exists_ (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [ impl_Meter__plus___Sized ], [ verifier; meter; offset; struct_def; type_args ] =>
      ltac:(M.monadic
        (let verifier := M.alloc (| verifier |) in
        let meter := M.alloc (| meter |) in
        let offset := M.alloc (| offset |) in
        let struct_def := M.alloc (| struct_def |) in
        let type_args := M.alloc (| type_args |) in
        M.catch_return (|
          ltac:(M.monadic
            (M.read (|
              let~ struct_type :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "move_bytecode_verifier::type_safety::materialize_type",
                      []
                    |),
                    [
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| struct_def |),
                          "move_binary_format::file_format::StructDefinition",
                          "struct_handle"
                        |)
                      |);
                      M.read (| type_args |)
                    ]
                  |)
                |) in
              let~ _ :=
                M.match_operator (|
                  M.alloc (| Value.Tuple [] |),
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ :=
                          M.use
                            (M.alloc (|
                              UnOp.not (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path "move_binary_format::file_format::AbilitySet",
                                    "has_key",
                                    []
                                  |),
                                  [
                                    M.read (|
                                      M.match_operator (|
                                        M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::ops::try_trait::Try",
                                              Ty.apply
                                                (Ty.path "core::result::Result")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::AbilitySet";
                                                  Ty.path
                                                    "move_binary_format::errors::PartialVMError"
                                                ],
                                              [],
                                              "branch",
                                              []
                                            |),
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path
                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "abilities",
                                                  []
                                                |),
                                                [ M.read (| verifier |); struct_type ]
                                              |)
                                            ]
                                          |)
                                        |),
                                        [
                                          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.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                        M.alloc (|
                          M.never_to_any (|
                            M.read (|
                              M.return_ (|
                                Value.StructTuple
                                  "core::result::Result::Err"
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                        "error",
                                        []
                                      |),
                                      [
                                        M.read (| verifier |);
                                        Value.StructTuple
                                          "move_core_types::vm_status::StatusCode::EXISTS_WITHOUT_KEY_ABILITY_OR_BAD_ARGUMENT"
                                          [];
                                        M.read (| offset |)
                                      ]
                                    |)
                                  ]
                              |)
                            |)
                          |)
                        |)));
                    fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                  ]
                |) in
              let~ operand :=
                M.copy (|
                  M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.apply
                            (Ty.path "move_abstract_stack::AbstractStack")
                            []
                            [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                          "pop",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| verifier |),
                            "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                            "stack"
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Ok",
                              0
                            |) in
                          let x := M.copy (| γ0_0 |) in
                          x));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Err",
                              0
                            |) in
                          let e := M.copy (| γ0_0 |) in
                          let~ err :=
                            M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::errors::PartialVMError",
                                  "with_message",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::errors::PartialVMError",
                                      "new",
                                      []
                                    |),
                                    [
                                      Value.StructTuple
                                        "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                        []
                                    ]
                                  |);
                                  M.call_closure (|
                                    M.get_function (|
                                      "core::hint::must_use",
                                      [ Ty.path "alloc::string::String" ]
                                    |),
                                    [
                                      M.read (|
                                        let~ res :=
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_function (| "alloc::fmt::format", [] |),
                                              [
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "core::fmt::Arguments",
                                                    "new_v1_formatted",
                                                    []
                                                  |),
                                                  [
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.read (|
                                                            Value.String
                                                              "crates/move-bytecode-verifier/src/type_safety.rs:368 "
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Argument",
                                                              "new_display",
                                                              [
                                                                Ty.path
                                                                  "move_abstract_stack::AbsStackError"
                                                              ]
                                                            |),
                                                            [ e ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Placeholder",
                                                              "new",
                                                              []
                                                            |),
                                                            [
                                                              Value.Integer IntegerKind.Usize 0;
                                                              Value.UnicodeChar 32;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Alignment::Unknown"
                                                                [];
                                                              Value.Integer IntegerKind.U32 4;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                [];
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                []
                                                            ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::UnsafeArg",
                                                        "new",
                                                        []
                                                      |),
                                                      []
                                                    |)
                                                  ]
                                                |)
                                              ]
                                            |)
                                          |) in
                                        res
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |) in
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.call_closure (|
                                        M.get_function (| "core::panicking::panic_fmt", [] |),
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "core::fmt::Arguments",
                                              "new_v1",
                                              []
                                            |),
                                            [
                                              M.alloc (|
                                                Value.Array [ M.read (| Value.String "" |) ]
                                              |);
                                              M.alloc (|
                                                Value.Array
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::Argument",
                                                        "new_debug",
                                                        [
                                                          Ty.path
                                                            "move_binary_format::errors::PartialVMError"
                                                        ]
                                                      |),
                                                      [ err ]
                                                    |)
                                                  ]
                                              |)
                                            ]
                                          |)
                                        ]
                                      |)
                                    |)
                                  |)));
                              fun γ =>
                                ltac:(M.monadic
                                  (M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [ M.read (| err |) ]
                                        |)
                                      |)
                                    |)
                                  |)))
                            ]
                          |)))
                    ]
                  |)
                |) in
              let~ _ :=
                M.match_operator (|
                  M.alloc (| Value.Tuple [] |),
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ :=
                          M.use
                            (M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.path "move_binary_format::file_format::SignatureToken",
                                  [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                  "ne",
                                  []
                                |),
                                [
                                  operand;
                                  M.alloc (|
                                    Value.StructTuple
                                      "move_binary_format::file_format::SignatureToken::Address"
                                      []
                                  |)
                                ]
                              |)
                            |)) in
                        let _ :=
                          M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                        M.alloc (|
                          M.never_to_any (|
                            M.read (|
                              M.return_ (|
                                Value.StructTuple
                                  "core::result::Result::Err"
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                        "error",
                                        []
                                      |),
                                      [
                                        M.read (| verifier |);
                                        Value.StructTuple
                                          "move_core_types::vm_status::StatusCode::EXISTS_WITHOUT_KEY_ABILITY_OR_BAD_ARGUMENT"
                                          [];
                                        M.read (| offset |)
                                      ]
                                    |)
                                  ]
                              |)
                            |)
                          |)
                        |)));
                    fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                  ]
                |) in
              let~ _ :=
                M.match_operator (|
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "core::ops::try_trait::Try",
                        Ty.apply
                          (Ty.path "core::result::Result")
                          []
                          [ Ty.tuple []; Ty.path "move_binary_format::errors::PartialVMError" ],
                        [],
                        "branch",
                        []
                      |),
                      [
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                            "push",
                            [ impl_Meter__plus___Sized ]
                          |),
                          [
                            M.read (| verifier |);
                            M.read (| meter |);
                            Value.StructTuple
                              "move_binary_format::file_format::SignatureToken::Bool"
                              []
                          ]
                        |)
                      ]
                    |)
                  |),
                  [
                    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.alloc (| Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ] |)
            |)))
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_exists_ : M.IsFunction "move_bytecode_verifier::type_safety::exists" exists_.
  
  (*
  fn move_from(
      verifier: &mut TypeSafetyChecker,
      meter: &mut (impl Meter + ?Sized),
      offset: CodeOffset,
      struct_def: &StructDefinition,
      type_args: &Signature,
  ) -> PartialVMResult<()> {
      let struct_type = materialize_type(struct_def.struct_handle, type_args);
      if !verifier.abilities(&struct_type)?.has_key() {
          return Err(verifier.error(StatusCode::MOVEFROM_WITHOUT_KEY_ABILITY, offset));
      }
  
      let struct_type = materialize_type(struct_def.struct_handle, type_args);
      let operand = safe_unwrap_err!(verifier.stack.pop());
      if operand != ST::Address {
          return Err(verifier.error(StatusCode::MOVEFROM_TYPE_MISMATCH_ERROR, offset));
      }
  
      verifier.push(meter, struct_type)?;
      Ok(())
  }
  *)
  Definition move_from (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [ impl_Meter__plus___Sized ], [ verifier; meter; offset; struct_def; type_args ] =>
      ltac:(M.monadic
        (let verifier := M.alloc (| verifier |) in
        let meter := M.alloc (| meter |) in
        let offset := M.alloc (| offset |) in
        let struct_def := M.alloc (| struct_def |) in
        let type_args := M.alloc (| type_args |) in
        M.catch_return (|
          ltac:(M.monadic
            (M.read (|
              let~ struct_type :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "move_bytecode_verifier::type_safety::materialize_type",
                      []
                    |),
                    [
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| struct_def |),
                          "move_binary_format::file_format::StructDefinition",
                          "struct_handle"
                        |)
                      |);
                      M.read (| type_args |)
                    ]
                  |)
                |) in
              let~ _ :=
                M.match_operator (|
                  M.alloc (| Value.Tuple [] |),
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ :=
                          M.use
                            (M.alloc (|
                              UnOp.not (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path "move_binary_format::file_format::AbilitySet",
                                    "has_key",
                                    []
                                  |),
                                  [
                                    M.read (|
                                      M.match_operator (|
                                        M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::ops::try_trait::Try",
                                              Ty.apply
                                                (Ty.path "core::result::Result")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::AbilitySet";
                                                  Ty.path
                                                    "move_binary_format::errors::PartialVMError"
                                                ],
                                              [],
                                              "branch",
                                              []
                                            |),
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path
                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "abilities",
                                                  []
                                                |),
                                                [ M.read (| verifier |); struct_type ]
                                              |)
                                            ]
                                          |)
                                        |),
                                        [
                                          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.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                        M.alloc (|
                          M.never_to_any (|
                            M.read (|
                              M.return_ (|
                                Value.StructTuple
                                  "core::result::Result::Err"
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                        "error",
                                        []
                                      |),
                                      [
                                        M.read (| verifier |);
                                        Value.StructTuple
                                          "move_core_types::vm_status::StatusCode::MOVEFROM_WITHOUT_KEY_ABILITY"
                                          [];
                                        M.read (| offset |)
                                      ]
                                    |)
                                  ]
                              |)
                            |)
                          |)
                        |)));
                    fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                  ]
                |) in
              let~ struct_type :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "move_bytecode_verifier::type_safety::materialize_type",
                      []
                    |),
                    [
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| struct_def |),
                          "move_binary_format::file_format::StructDefinition",
                          "struct_handle"
                        |)
                      |);
                      M.read (| type_args |)
                    ]
                  |)
                |) in
              let~ operand :=
                M.copy (|
                  M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.apply
                            (Ty.path "move_abstract_stack::AbstractStack")
                            []
                            [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                          "pop",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| verifier |),
                            "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                            "stack"
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Ok",
                              0
                            |) in
                          let x := M.copy (| γ0_0 |) in
                          x));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Err",
                              0
                            |) in
                          let e := M.copy (| γ0_0 |) in
                          let~ err :=
                            M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::errors::PartialVMError",
                                  "with_message",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::errors::PartialVMError",
                                      "new",
                                      []
                                    |),
                                    [
                                      Value.StructTuple
                                        "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                        []
                                    ]
                                  |);
                                  M.call_closure (|
                                    M.get_function (|
                                      "core::hint::must_use",
                                      [ Ty.path "alloc::string::String" ]
                                    |),
                                    [
                                      M.read (|
                                        let~ res :=
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_function (| "alloc::fmt::format", [] |),
                                              [
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "core::fmt::Arguments",
                                                    "new_v1_formatted",
                                                    []
                                                  |),
                                                  [
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.read (|
                                                            Value.String
                                                              "crates/move-bytecode-verifier/src/type_safety.rs:394 "
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Argument",
                                                              "new_display",
                                                              [
                                                                Ty.path
                                                                  "move_abstract_stack::AbsStackError"
                                                              ]
                                                            |),
                                                            [ e ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Placeholder",
                                                              "new",
                                                              []
                                                            |),
                                                            [
                                                              Value.Integer IntegerKind.Usize 0;
                                                              Value.UnicodeChar 32;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Alignment::Unknown"
                                                                [];
                                                              Value.Integer IntegerKind.U32 4;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                [];
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                []
                                                            ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::UnsafeArg",
                                                        "new",
                                                        []
                                                      |),
                                                      []
                                                    |)
                                                  ]
                                                |)
                                              ]
                                            |)
                                          |) in
                                        res
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |) in
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.call_closure (|
                                        M.get_function (| "core::panicking::panic_fmt", [] |),
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "core::fmt::Arguments",
                                              "new_v1",
                                              []
                                            |),
                                            [
                                              M.alloc (|
                                                Value.Array [ M.read (| Value.String "" |) ]
                                              |);
                                              M.alloc (|
                                                Value.Array
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::Argument",
                                                        "new_debug",
                                                        [
                                                          Ty.path
                                                            "move_binary_format::errors::PartialVMError"
                                                        ]
                                                      |),
                                                      [ err ]
                                                    |)
                                                  ]
                                              |)
                                            ]
                                          |)
                                        ]
                                      |)
                                    |)
                                  |)));
                              fun γ =>
                                ltac:(M.monadic
                                  (M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [ M.read (| err |) ]
                                        |)
                                      |)
                                    |)
                                  |)))
                            ]
                          |)))
                    ]
                  |)
                |) in
              let~ _ :=
                M.match_operator (|
                  M.alloc (| Value.Tuple [] |),
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ :=
                          M.use
                            (M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.path "move_binary_format::file_format::SignatureToken",
                                  [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                  "ne",
                                  []
                                |),
                                [
                                  operand;
                                  M.alloc (|
                                    Value.StructTuple
                                      "move_binary_format::file_format::SignatureToken::Address"
                                      []
                                  |)
                                ]
                              |)
                            |)) in
                        let _ :=
                          M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                        M.alloc (|
                          M.never_to_any (|
                            M.read (|
                              M.return_ (|
                                Value.StructTuple
                                  "core::result::Result::Err"
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                        "error",
                                        []
                                      |),
                                      [
                                        M.read (| verifier |);
                                        Value.StructTuple
                                          "move_core_types::vm_status::StatusCode::MOVEFROM_TYPE_MISMATCH_ERROR"
                                          [];
                                        M.read (| offset |)
                                      ]
                                    |)
                                  ]
                              |)
                            |)
                          |)
                        |)));
                    fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                  ]
                |) in
              let~ _ :=
                M.match_operator (|
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "core::ops::try_trait::Try",
                        Ty.apply
                          (Ty.path "core::result::Result")
                          []
                          [ Ty.tuple []; Ty.path "move_binary_format::errors::PartialVMError" ],
                        [],
                        "branch",
                        []
                      |),
                      [
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                            "push",
                            [ impl_Meter__plus___Sized ]
                          |),
                          [ M.read (| verifier |); M.read (| meter |); M.read (| struct_type |) ]
                        |)
                      ]
                    |)
                  |),
                  [
                    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.alloc (| Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ] |)
            |)))
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_move_from :
    M.IsFunction "move_bytecode_verifier::type_safety::move_from" move_from.
  
  (*
  fn move_to(
      verifier: &mut TypeSafetyChecker,
      offset: CodeOffset,
      struct_def: &StructDefinition,
      type_args: &Signature,
  ) -> PartialVMResult<()> {
      let struct_type = materialize_type(struct_def.struct_handle, type_args);
      if !verifier.abilities(&struct_type)?.has_key() {
          return Err(verifier.error(StatusCode::MOVETO_WITHOUT_KEY_ABILITY, offset));
      }
  
      let struct_type = materialize_type(struct_def.struct_handle, type_args);
      let key_struct_operand = safe_unwrap_err!(verifier.stack.pop());
      let signer_reference_operand = safe_unwrap_err!(verifier.stack.pop());
      if key_struct_operand != struct_type {
          return Err(verifier.error(StatusCode::MOVETO_TYPE_MISMATCH_ERROR, offset));
      }
      match signer_reference_operand {
          ST::Reference(inner) => match *inner {
              ST::Signer => Ok(()),
              _ => Err(verifier.error(StatusCode::MOVETO_TYPE_MISMATCH_ERROR, offset)),
          },
          _ => Err(verifier.error(StatusCode::MOVETO_TYPE_MISMATCH_ERROR, offset)),
      }
  }
  *)
  Definition move_to (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [], [ verifier; offset; struct_def; type_args ] =>
      ltac:(M.monadic
        (let verifier := M.alloc (| verifier |) in
        let offset := M.alloc (| offset |) in
        let struct_def := M.alloc (| struct_def |) in
        let type_args := M.alloc (| type_args |) in
        M.catch_return (|
          ltac:(M.monadic
            (M.read (|
              let~ struct_type :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "move_bytecode_verifier::type_safety::materialize_type",
                      []
                    |),
                    [
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| struct_def |),
                          "move_binary_format::file_format::StructDefinition",
                          "struct_handle"
                        |)
                      |);
                      M.read (| type_args |)
                    ]
                  |)
                |) in
              let~ _ :=
                M.match_operator (|
                  M.alloc (| Value.Tuple [] |),
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ :=
                          M.use
                            (M.alloc (|
                              UnOp.not (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path "move_binary_format::file_format::AbilitySet",
                                    "has_key",
                                    []
                                  |),
                                  [
                                    M.read (|
                                      M.match_operator (|
                                        M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::ops::try_trait::Try",
                                              Ty.apply
                                                (Ty.path "core::result::Result")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::AbilitySet";
                                                  Ty.path
                                                    "move_binary_format::errors::PartialVMError"
                                                ],
                                              [],
                                              "branch",
                                              []
                                            |),
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path
                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "abilities",
                                                  []
                                                |),
                                                [ M.read (| verifier |); struct_type ]
                                              |)
                                            ]
                                          |)
                                        |),
                                        [
                                          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.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                        M.alloc (|
                          M.never_to_any (|
                            M.read (|
                              M.return_ (|
                                Value.StructTuple
                                  "core::result::Result::Err"
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                        "error",
                                        []
                                      |),
                                      [
                                        M.read (| verifier |);
                                        Value.StructTuple
                                          "move_core_types::vm_status::StatusCode::MOVETO_WITHOUT_KEY_ABILITY"
                                          [];
                                        M.read (| offset |)
                                      ]
                                    |)
                                  ]
                              |)
                            |)
                          |)
                        |)));
                    fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                  ]
                |) in
              let~ struct_type :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "move_bytecode_verifier::type_safety::materialize_type",
                      []
                    |),
                    [
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| struct_def |),
                          "move_binary_format::file_format::StructDefinition",
                          "struct_handle"
                        |)
                      |);
                      M.read (| type_args |)
                    ]
                  |)
                |) in
              let~ key_struct_operand :=
                M.copy (|
                  M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.apply
                            (Ty.path "move_abstract_stack::AbstractStack")
                            []
                            [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                          "pop",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| verifier |),
                            "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                            "stack"
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Ok",
                              0
                            |) in
                          let x := M.copy (| γ0_0 |) in
                          x));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Err",
                              0
                            |) in
                          let e := M.copy (| γ0_0 |) in
                          let~ err :=
                            M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::errors::PartialVMError",
                                  "with_message",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::errors::PartialVMError",
                                      "new",
                                      []
                                    |),
                                    [
                                      Value.StructTuple
                                        "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                        []
                                    ]
                                  |);
                                  M.call_closure (|
                                    M.get_function (|
                                      "core::hint::must_use",
                                      [ Ty.path "alloc::string::String" ]
                                    |),
                                    [
                                      M.read (|
                                        let~ res :=
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_function (| "alloc::fmt::format", [] |),
                                              [
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "core::fmt::Arguments",
                                                    "new_v1_formatted",
                                                    []
                                                  |),
                                                  [
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.read (|
                                                            Value.String
                                                              "crates/move-bytecode-verifier/src/type_safety.rs:415 "
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Argument",
                                                              "new_display",
                                                              [
                                                                Ty.path
                                                                  "move_abstract_stack::AbsStackError"
                                                              ]
                                                            |),
                                                            [ e ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Placeholder",
                                                              "new",
                                                              []
                                                            |),
                                                            [
                                                              Value.Integer IntegerKind.Usize 0;
                                                              Value.UnicodeChar 32;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Alignment::Unknown"
                                                                [];
                                                              Value.Integer IntegerKind.U32 4;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                [];
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                []
                                                            ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::UnsafeArg",
                                                        "new",
                                                        []
                                                      |),
                                                      []
                                                    |)
                                                  ]
                                                |)
                                              ]
                                            |)
                                          |) in
                                        res
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |) in
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.call_closure (|
                                        M.get_function (| "core::panicking::panic_fmt", [] |),
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "core::fmt::Arguments",
                                              "new_v1",
                                              []
                                            |),
                                            [
                                              M.alloc (|
                                                Value.Array [ M.read (| Value.String "" |) ]
                                              |);
                                              M.alloc (|
                                                Value.Array
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::Argument",
                                                        "new_debug",
                                                        [
                                                          Ty.path
                                                            "move_binary_format::errors::PartialVMError"
                                                        ]
                                                      |),
                                                      [ err ]
                                                    |)
                                                  ]
                                              |)
                                            ]
                                          |)
                                        ]
                                      |)
                                    |)
                                  |)));
                              fun γ =>
                                ltac:(M.monadic
                                  (M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [ M.read (| err |) ]
                                        |)
                                      |)
                                    |)
                                  |)))
                            ]
                          |)))
                    ]
                  |)
                |) in
              let~ signer_reference_operand :=
                M.copy (|
                  M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.apply
                            (Ty.path "move_abstract_stack::AbstractStack")
                            []
                            [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                          "pop",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| verifier |),
                            "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                            "stack"
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Ok",
                              0
                            |) in
                          let x := M.copy (| γ0_0 |) in
                          x));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Err",
                              0
                            |) in
                          let e := M.copy (| γ0_0 |) in
                          let~ err :=
                            M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::errors::PartialVMError",
                                  "with_message",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::errors::PartialVMError",
                                      "new",
                                      []
                                    |),
                                    [
                                      Value.StructTuple
                                        "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                        []
                                    ]
                                  |);
                                  M.call_closure (|
                                    M.get_function (|
                                      "core::hint::must_use",
                                      [ Ty.path "alloc::string::String" ]
                                    |),
                                    [
                                      M.read (|
                                        let~ res :=
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_function (| "alloc::fmt::format", [] |),
                                              [
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "core::fmt::Arguments",
                                                    "new_v1_formatted",
                                                    []
                                                  |),
                                                  [
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.read (|
                                                            Value.String
                                                              "crates/move-bytecode-verifier/src/type_safety.rs:416 "
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Argument",
                                                              "new_display",
                                                              [
                                                                Ty.path
                                                                  "move_abstract_stack::AbsStackError"
                                                              ]
                                                            |),
                                                            [ e ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Placeholder",
                                                              "new",
                                                              []
                                                            |),
                                                            [
                                                              Value.Integer IntegerKind.Usize 0;
                                                              Value.UnicodeChar 32;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Alignment::Unknown"
                                                                [];
                                                              Value.Integer IntegerKind.U32 4;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                [];
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                []
                                                            ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::UnsafeArg",
                                                        "new",
                                                        []
                                                      |),
                                                      []
                                                    |)
                                                  ]
                                                |)
                                              ]
                                            |)
                                          |) in
                                        res
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |) in
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.call_closure (|
                                        M.get_function (| "core::panicking::panic_fmt", [] |),
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "core::fmt::Arguments",
                                              "new_v1",
                                              []
                                            |),
                                            [
                                              M.alloc (|
                                                Value.Array [ M.read (| Value.String "" |) ]
                                              |);
                                              M.alloc (|
                                                Value.Array
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::Argument",
                                                        "new_debug",
                                                        [
                                                          Ty.path
                                                            "move_binary_format::errors::PartialVMError"
                                                        ]
                                                      |),
                                                      [ err ]
                                                    |)
                                                  ]
                                              |)
                                            ]
                                          |)
                                        ]
                                      |)
                                    |)
                                  |)));
                              fun γ =>
                                ltac:(M.monadic
                                  (M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [ M.read (| err |) ]
                                        |)
                                      |)
                                    |)
                                  |)))
                            ]
                          |)))
                    ]
                  |)
                |) in
              let~ _ :=
                M.match_operator (|
                  M.alloc (| Value.Tuple [] |),
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ :=
                          M.use
                            (M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.path "move_binary_format::file_format::SignatureToken",
                                  [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                  "ne",
                                  []
                                |),
                                [ key_struct_operand; struct_type ]
                              |)
                            |)) in
                        let _ :=
                          M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                        M.alloc (|
                          M.never_to_any (|
                            M.read (|
                              M.return_ (|
                                Value.StructTuple
                                  "core::result::Result::Err"
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                        "error",
                                        []
                                      |),
                                      [
                                        M.read (| verifier |);
                                        Value.StructTuple
                                          "move_core_types::vm_status::StatusCode::MOVETO_TYPE_MISMATCH_ERROR"
                                          [];
                                        M.read (| offset |)
                                      ]
                                    |)
                                  ]
                              |)
                            |)
                          |)
                        |)));
                    fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                  ]
                |) in
              M.match_operator (|
                signer_reference_operand,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "move_binary_format::file_format::SignatureToken::Reference",
                          0
                        |) in
                      let inner := M.copy (| γ0_0 |) in
                      M.match_operator (|
                        M.read (| inner |),
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let _ :=
                                M.is_struct_tuple (|
                                  γ,
                                  "move_binary_format::file_format::SignatureToken::Signer"
                                |) in
                              M.alloc (|
                                Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ]
                              |)));
                          fun γ =>
                            ltac:(M.monadic
                              (M.alloc (|
                                Value.StructTuple
                                  "core::result::Result::Err"
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                        "error",
                                        []
                                      |),
                                      [
                                        M.read (| verifier |);
                                        Value.StructTuple
                                          "move_core_types::vm_status::StatusCode::MOVETO_TYPE_MISMATCH_ERROR"
                                          [];
                                        M.read (| offset |)
                                      ]
                                    |)
                                  ]
                              |)))
                        ]
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (M.alloc (|
                        Value.StructTuple
                          "core::result::Result::Err"
                          [
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                "error",
                                []
                              |),
                              [
                                M.read (| verifier |);
                                Value.StructTuple
                                  "move_core_types::vm_status::StatusCode::MOVETO_TYPE_MISMATCH_ERROR"
                                  [];
                                M.read (| offset |)
                              ]
                            |)
                          ]
                      |)))
                ]
              |)
            |)))
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_move_to : M.IsFunction "move_bytecode_verifier::type_safety::move_to" move_to.
  
  (*
  fn borrow_vector_element(
      verifier: &mut TypeSafetyChecker,
      meter: &mut (impl Meter + ?Sized),
      declared_element_type: &SignatureToken,
      offset: CodeOffset,
      mut_ref_only: bool,
  ) -> PartialVMResult<()> {
      let operand_idx = safe_unwrap_err!(verifier.stack.pop());
      let operand_vec = safe_unwrap_err!(verifier.stack.pop());
  
      // check index
      if operand_idx != ST::U64 {
          return Err(verifier.error(StatusCode::TYPE_MISMATCH, offset));
      }
  
      // check vector and update stack
      let element_type = match get_vector_element_type(operand_vec, mut_ref_only) {
          Some(ty) if &ty == declared_element_type => ty,
          _ => return Err(verifier.error(StatusCode::TYPE_MISMATCH, offset)),
      };
      let element_ref_type = if mut_ref_only {
          ST::MutableReference(Box::new(element_type))
      } else {
          ST::Reference(Box::new(element_type))
      };
      verifier.push(meter, element_ref_type)?;
  
      Ok(())
  }
  *)
  Definition borrow_vector_element (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [],
        [ impl_Meter__plus___Sized ],
        [ verifier; meter; declared_element_type; offset; mut_ref_only ] =>
      ltac:(M.monadic
        (let verifier := M.alloc (| verifier |) in
        let meter := M.alloc (| meter |) in
        let declared_element_type := M.alloc (| declared_element_type |) in
        let offset := M.alloc (| offset |) in
        let mut_ref_only := M.alloc (| mut_ref_only |) in
        M.catch_return (|
          ltac:(M.monadic
            (M.read (|
              let~ operand_idx :=
                M.copy (|
                  M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.apply
                            (Ty.path "move_abstract_stack::AbstractStack")
                            []
                            [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                          "pop",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| verifier |),
                            "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                            "stack"
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Ok",
                              0
                            |) in
                          let x := M.copy (| γ0_0 |) in
                          x));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Err",
                              0
                            |) in
                          let e := M.copy (| γ0_0 |) in
                          let~ err :=
                            M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::errors::PartialVMError",
                                  "with_message",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::errors::PartialVMError",
                                      "new",
                                      []
                                    |),
                                    [
                                      Value.StructTuple
                                        "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                        []
                                    ]
                                  |);
                                  M.call_closure (|
                                    M.get_function (|
                                      "core::hint::must_use",
                                      [ Ty.path "alloc::string::String" ]
                                    |),
                                    [
                                      M.read (|
                                        let~ res :=
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_function (| "alloc::fmt::format", [] |),
                                              [
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "core::fmt::Arguments",
                                                    "new_v1_formatted",
                                                    []
                                                  |),
                                                  [
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.read (|
                                                            Value.String
                                                              "crates/move-bytecode-verifier/src/type_safety.rs:436 "
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Argument",
                                                              "new_display",
                                                              [
                                                                Ty.path
                                                                  "move_abstract_stack::AbsStackError"
                                                              ]
                                                            |),
                                                            [ e ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Placeholder",
                                                              "new",
                                                              []
                                                            |),
                                                            [
                                                              Value.Integer IntegerKind.Usize 0;
                                                              Value.UnicodeChar 32;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Alignment::Unknown"
                                                                [];
                                                              Value.Integer IntegerKind.U32 4;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                [];
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                []
                                                            ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::UnsafeArg",
                                                        "new",
                                                        []
                                                      |),
                                                      []
                                                    |)
                                                  ]
                                                |)
                                              ]
                                            |)
                                          |) in
                                        res
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |) in
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.call_closure (|
                                        M.get_function (| "core::panicking::panic_fmt", [] |),
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "core::fmt::Arguments",
                                              "new_v1",
                                              []
                                            |),
                                            [
                                              M.alloc (|
                                                Value.Array [ M.read (| Value.String "" |) ]
                                              |);
                                              M.alloc (|
                                                Value.Array
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::Argument",
                                                        "new_debug",
                                                        [
                                                          Ty.path
                                                            "move_binary_format::errors::PartialVMError"
                                                        ]
                                                      |),
                                                      [ err ]
                                                    |)
                                                  ]
                                              |)
                                            ]
                                          |)
                                        ]
                                      |)
                                    |)
                                  |)));
                              fun γ =>
                                ltac:(M.monadic
                                  (M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [ M.read (| err |) ]
                                        |)
                                      |)
                                    |)
                                  |)))
                            ]
                          |)))
                    ]
                  |)
                |) in
              let~ operand_vec :=
                M.copy (|
                  M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.apply
                            (Ty.path "move_abstract_stack::AbstractStack")
                            []
                            [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                          "pop",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| verifier |),
                            "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                            "stack"
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Ok",
                              0
                            |) in
                          let x := M.copy (| γ0_0 |) in
                          x));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::result::Result::Err",
                              0
                            |) in
                          let e := M.copy (| γ0_0 |) in
                          let~ err :=
                            M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::errors::PartialVMError",
                                  "with_message",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::errors::PartialVMError",
                                      "new",
                                      []
                                    |),
                                    [
                                      Value.StructTuple
                                        "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                        []
                                    ]
                                  |);
                                  M.call_closure (|
                                    M.get_function (|
                                      "core::hint::must_use",
                                      [ Ty.path "alloc::string::String" ]
                                    |),
                                    [
                                      M.read (|
                                        let~ res :=
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_function (| "alloc::fmt::format", [] |),
                                              [
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "core::fmt::Arguments",
                                                    "new_v1_formatted",
                                                    []
                                                  |),
                                                  [
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.read (|
                                                            Value.String
                                                              "crates/move-bytecode-verifier/src/type_safety.rs:437 "
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Argument",
                                                              "new_display",
                                                              [
                                                                Ty.path
                                                                  "move_abstract_stack::AbsStackError"
                                                              ]
                                                            |),
                                                            [ e ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.alloc (|
                                                      Value.Array
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::rt::Placeholder",
                                                              "new",
                                                              []
                                                            |),
                                                            [
                                                              Value.Integer IntegerKind.Usize 0;
                                                              Value.UnicodeChar 32;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Alignment::Unknown"
                                                                [];
                                                              Value.Integer IntegerKind.U32 4;
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                [];
                                                              Value.StructTuple
                                                                "core::fmt::rt::Count::Implied"
                                                                []
                                                            ]
                                                          |)
                                                        ]
                                                    |);
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::UnsafeArg",
                                                        "new",
                                                        []
                                                      |),
                                                      []
                                                    |)
                                                  ]
                                                |)
                                              ]
                                            |)
                                          |) in
                                        res
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |) in
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.call_closure (|
                                        M.get_function (| "core::panicking::panic_fmt", [] |),
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "core::fmt::Arguments",
                                              "new_v1",
                                              []
                                            |),
                                            [
                                              M.alloc (|
                                                Value.Array [ M.read (| Value.String "" |) ]
                                              |);
                                              M.alloc (|
                                                Value.Array
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::Argument",
                                                        "new_debug",
                                                        [
                                                          Ty.path
                                                            "move_binary_format::errors::PartialVMError"
                                                        ]
                                                      |),
                                                      [ err ]
                                                    |)
                                                  ]
                                              |)
                                            ]
                                          |)
                                        ]
                                      |)
                                    |)
                                  |)));
                              fun γ =>
                                ltac:(M.monadic
                                  (M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [ M.read (| err |) ]
                                        |)
                                      |)
                                    |)
                                  |)))
                            ]
                          |)))
                    ]
                  |)
                |) in
              let~ _ :=
                M.match_operator (|
                  M.alloc (| Value.Tuple [] |),
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ :=
                          M.use
                            (M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.path "move_binary_format::file_format::SignatureToken",
                                  [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                  "ne",
                                  []
                                |),
                                [
                                  operand_idx;
                                  M.alloc (|
                                    Value.StructTuple
                                      "move_binary_format::file_format::SignatureToken::U64"
                                      []
                                  |)
                                ]
                              |)
                            |)) in
                        let _ :=
                          M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                        M.alloc (|
                          M.never_to_any (|
                            M.read (|
                              M.return_ (|
                                Value.StructTuple
                                  "core::result::Result::Err"
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                        "error",
                                        []
                                      |),
                                      [
                                        M.read (| verifier |);
                                        Value.StructTuple
                                          "move_core_types::vm_status::StatusCode::TYPE_MISMATCH"
                                          [];
                                        M.read (| offset |)
                                      ]
                                    |)
                                  ]
                              |)
                            |)
                          |)
                        |)));
                    fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                  ]
                |) in
              let~ element_type :=
                M.copy (|
                  M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_function (|
                          "move_bytecode_verifier::type_safety::get_vector_element_type",
                          []
                        |),
                        [ M.read (| operand_vec |); M.read (| mut_ref_only |) ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::option::Option::Some",
                              0
                            |) in
                          let ty := M.copy (| γ0_0 |) in
                          let γ :=
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "&")
                                    []
                                    [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                  [
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [ M.alloc (| ty |); declared_element_type ]
                              |)
                            |) in
                          let _ :=
                            M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                          ty));
                      fun γ =>
                        ltac:(M.monadic
                          (M.alloc (|
                            M.never_to_any (|
                              M.read (|
                                M.return_ (|
                                  Value.StructTuple
                                    "core::result::Result::Err"
                                    [
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.path
                                            "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                          "error",
                                          []
                                        |),
                                        [
                                          M.read (| verifier |);
                                          Value.StructTuple
                                            "move_core_types::vm_status::StatusCode::TYPE_MISMATCH"
                                            [];
                                          M.read (| offset |)
                                        ]
                                      |)
                                    ]
                                |)
                              |)
                            |)
                          |)))
                    ]
                  |)
                |) in
              let~ element_ref_type :=
                M.copy (|
                  M.match_operator (|
                    M.alloc (| Value.Tuple [] |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.use mut_ref_only in
                          let _ :=
                            M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                          M.alloc (|
                            Value.StructTuple
                              "move_binary_format::file_format::SignatureToken::MutableReference"
                              [
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "alloc::boxed::Box")
                                      []
                                      [
                                        Ty.path "move_binary_format::file_format::SignatureToken";
                                        Ty.path "alloc::alloc::Global"
                                      ],
                                    "new",
                                    []
                                  |),
                                  [ M.read (| element_type |) ]
                                |)
                              ]
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (M.alloc (|
                            Value.StructTuple
                              "move_binary_format::file_format::SignatureToken::Reference"
                              [
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "alloc::boxed::Box")
                                      []
                                      [
                                        Ty.path "move_binary_format::file_format::SignatureToken";
                                        Ty.path "alloc::alloc::Global"
                                      ],
                                    "new",
                                    []
                                  |),
                                  [ M.read (| element_type |) ]
                                |)
                              ]
                          |)))
                    ]
                  |)
                |) 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_associated_function (|
                            Ty.path "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                            "push",
                            [ impl_Meter__plus___Sized ]
                          |),
                          [ M.read (| verifier |); M.read (| meter |); M.read (| element_ref_type |)
                          ]
                        |)
                      ]
                    |)
                  |),
                  [
                    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.alloc (| Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ] |)
            |)))
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_borrow_vector_element :
    M.IsFunction "move_bytecode_verifier::type_safety::borrow_vector_element" borrow_vector_element.
  
  (*
  fn verify_instr(
      verifier: &mut TypeSafetyChecker,
      bytecode: &Bytecode,
      offset: CodeOffset,
      meter: &mut (impl Meter + ?Sized),
  ) -> PartialVMResult<()> {
      match bytecode {
          Bytecode::Pop => {
              let operand = safe_unwrap_err!(verifier.stack.pop());
              let abilities = verifier
                  .module
                  .abilities(&operand, verifier.function_context.type_parameters());
              if !abilities?.has_drop() {
                  return Err(verifier.error(StatusCode::POP_WITHOUT_DROP_ABILITY, offset));
              }
          }
  
          Bytecode::BrTrue(_) | Bytecode::BrFalse(_) => {
              let operand = safe_unwrap_err!(verifier.stack.pop());
              if operand != ST::Bool {
                  return Err(verifier.error(StatusCode::BR_TYPE_MISMATCH_ERROR, offset));
              }
          }
  
          Bytecode::StLoc(idx) => {
              let operand = safe_unwrap_err!(verifier.stack.pop());
              if &operand != verifier.local_at( *idx) {
                  return Err(verifier.error(StatusCode::STLOC_TYPE_MISMATCH_ERROR, offset));
              }
          }
  
          Bytecode::Abort => {
              let operand = safe_unwrap_err!(verifier.stack.pop());
              if operand != ST::U64 {
                  return Err(verifier.error(StatusCode::ABORT_TYPE_MISMATCH_ERROR, offset));
              }
          }
  
          Bytecode::Ret => {
              let return_ = &verifier.function_context.return_().0;
              for return_type in return_.iter().rev() {
                  let operand = safe_unwrap_err!(verifier.stack.pop());
                  if &operand != return_type {
                      return Err(verifier.error(StatusCode::RET_TYPE_MISMATCH_ERROR, offset));
                  }
              }
          }
  
          Bytecode::Branch(_) | Bytecode::Nop => (),
  
          Bytecode::FreezeRef => {
              let operand = safe_unwrap_err!(verifier.stack.pop());
              match operand {
                  ST::MutableReference(inner) => verifier.push(meter, ST::Reference(inner))?,
                  _ => return Err(verifier.error(StatusCode::FREEZEREF_TYPE_MISMATCH_ERROR, offset)),
              }
          }
  
          Bytecode::MutBorrowField(field_handle_index) => borrow_field(
              verifier,
              meter,
              offset,
              true,
              *field_handle_index,
              &Signature(vec![]),
          )?,
  
          Bytecode::MutBorrowFieldGeneric(field_inst_index) => {
              let field_inst = verifier.module.field_instantiation_at( *field_inst_index);
              let type_inst = verifier.module.signature_at(field_inst.type_parameters);
              verifier.charge_tys(meter, &type_inst.0)?;
              borrow_field(verifier, meter, offset, true, field_inst.handle, type_inst)?
          }
  
          Bytecode::ImmBorrowField(field_handle_index) => borrow_field(
              verifier,
              meter,
              offset,
              false,
              *field_handle_index,
              &Signature(vec![]),
          )?,
  
          Bytecode::ImmBorrowFieldGeneric(field_inst_index) => {
              let field_inst = verifier.module.field_instantiation_at( *field_inst_index);
              let type_inst = verifier.module.signature_at(field_inst.type_parameters);
              verifier.charge_tys(meter, &type_inst.0)?;
              borrow_field(verifier, meter, offset, false, field_inst.handle, type_inst)?
          }
  
          Bytecode::LdU8(_) => {
              verifier.push(meter, ST::U8)?;
          }
  
          Bytecode::LdU16(_) => {
              verifier.push(meter, ST::U16)?;
          }
  
          Bytecode::LdU32(_) => {
              verifier.push(meter, ST::U32)?;
          }
  
          Bytecode::LdU64(_) => {
              verifier.push(meter, ST::U64)?;
          }
  
          Bytecode::LdU128(_) => {
              verifier.push(meter, ST::U128)?;
          }
  
          Bytecode::LdU256(_) => {
              verifier.push(meter, ST::U256)?;
          }
  
          Bytecode::LdConst(idx) => {
              let signature = verifier.module.constant_at( *idx).type_.clone();
              verifier.push(meter, signature)?;
          }
  
          Bytecode::LdTrue | Bytecode::LdFalse => {
              verifier.push(meter, ST::Bool)?;
          }
  
          Bytecode::CopyLoc(idx) => {
              let local_signature = verifier.local_at( *idx).clone();
              if !verifier
                  .module
                  .abilities(
                      &local_signature,
                      verifier.function_context.type_parameters(),
                  )?
                  .has_copy()
              {
                  return Err(verifier.error(StatusCode::COPYLOC_WITHOUT_COPY_ABILITY, offset));
              }
              verifier.push(meter, local_signature)?
          }
  
          Bytecode::MoveLoc(idx) => {
              let local_signature = verifier.local_at( *idx).clone();
              verifier.push(meter, local_signature)?
          }
  
          Bytecode::MutBorrowLoc(idx) => borrow_loc(verifier, meter, offset, true, *idx)?,
  
          Bytecode::ImmBorrowLoc(idx) => borrow_loc(verifier, meter, offset, false, *idx)?,
  
          Bytecode::Call(idx) => {
              let function_handle = verifier.module.function_handle_at( *idx);
              call(verifier, meter, offset, function_handle, &Signature(vec![]))?
          }
  
          Bytecode::CallGeneric(idx) => {
              let func_inst = verifier.module.function_instantiation_at( *idx);
              let func_handle = verifier.module.function_handle_at(func_inst.handle);
              let type_args = &verifier.module.signature_at(func_inst.type_parameters);
              verifier.charge_tys(meter, &type_args.0)?;
              call(verifier, meter, offset, func_handle, type_args)?
          }
  
          Bytecode::Pack(idx) => {
              let struct_definition = verifier.module.struct_def_at( *idx);
              pack(
                  verifier,
                  meter,
                  offset,
                  struct_definition,
                  &Signature(vec![]),
              )?
          }
  
          Bytecode::PackGeneric(idx) => {
              let struct_inst = verifier.module.struct_instantiation_at( *idx);
              let struct_def = verifier.module.struct_def_at(struct_inst.def);
              let type_args = verifier.module.signature_at(struct_inst.type_parameters);
              verifier.charge_tys(meter, &type_args.0)?;
              pack(verifier, meter, offset, struct_def, type_args)?
          }
  
          Bytecode::Unpack(idx) => {
              let struct_definition = verifier.module.struct_def_at( *idx);
              unpack(
                  verifier,
                  meter,
                  offset,
                  struct_definition,
                  &Signature(vec![]),
              )?
          }
  
          Bytecode::UnpackGeneric(idx) => {
              let struct_inst = verifier.module.struct_instantiation_at( *idx);
              let struct_def = verifier.module.struct_def_at(struct_inst.def);
              let type_args = verifier.module.signature_at(struct_inst.type_parameters);
              verifier.charge_tys(meter, &type_args.0)?;
              unpack(verifier, meter, offset, struct_def, type_args)?
          }
  
          Bytecode::ReadRef => {
              let operand = safe_unwrap_err!(verifier.stack.pop());
              match operand {
                  ST::Reference(inner) | ST::MutableReference(inner) => {
                      if !verifier.abilities(&inner)?.has_copy() {
                          return Err(
                              verifier.error(StatusCode::READREF_WITHOUT_COPY_ABILITY, offset)
                          );
                      }
                      verifier.push(meter, *inner)?;
                  }
                  _ => return Err(verifier.error(StatusCode::READREF_TYPE_MISMATCH_ERROR, offset)),
              }
          }
  
          Bytecode::WriteRef => {
              let ref_operand = safe_unwrap_err!(verifier.stack.pop());
              let val_operand = safe_unwrap_err!(verifier.stack.pop());
              let ref_inner_signature = match ref_operand {
                  ST::MutableReference(inner) => *inner,
                  _ => {
                      return Err(
                          verifier.error(StatusCode::WRITEREF_NO_MUTABLE_REFERENCE_ERROR, offset)
                      )
                  }
              };
              if !verifier.abilities(&ref_inner_signature)?.has_drop() {
                  return Err(verifier.error(StatusCode::WRITEREF_WITHOUT_DROP_ABILITY, offset));
              }
  
              if val_operand != ref_inner_signature {
                  return Err(verifier.error(StatusCode::WRITEREF_TYPE_MISMATCH_ERROR, offset));
              }
          }
  
          Bytecode::CastU8 => {
              let operand = safe_unwrap_err!(verifier.stack.pop());
              if !operand.is_integer() {
                  return Err(verifier.error(StatusCode::INTEGER_OP_TYPE_MISMATCH_ERROR, offset));
              }
              verifier.push(meter, ST::U8)?;
          }
          Bytecode::CastU64 => {
              let operand = safe_unwrap_err!(verifier.stack.pop());
              if !operand.is_integer() {
                  return Err(verifier.error(StatusCode::INTEGER_OP_TYPE_MISMATCH_ERROR, offset));
              }
              verifier.push(meter, ST::U64)?;
          }
          Bytecode::CastU128 => {
              let operand = safe_unwrap_err!(verifier.stack.pop());
              if !operand.is_integer() {
                  return Err(verifier.error(StatusCode::INTEGER_OP_TYPE_MISMATCH_ERROR, offset));
              }
              verifier.push(meter, ST::U128)?;
          }
  
          Bytecode::Add
          | Bytecode::Sub
          | Bytecode::Mul
          | Bytecode::Mod
          | Bytecode::Div
          | Bytecode::BitOr
          | Bytecode::BitAnd
          | Bytecode::Xor => {
              let operand1 = safe_unwrap_err!(verifier.stack.pop());
              let operand2 = safe_unwrap_err!(verifier.stack.pop());
              if operand1.is_integer() && operand1 == operand2 {
                  verifier.push(meter, operand1)?;
              } else {
                  return Err(verifier.error(StatusCode::INTEGER_OP_TYPE_MISMATCH_ERROR, offset));
              }
          }
  
          Bytecode::Shl | Bytecode::Shr => {
              let operand1 = safe_unwrap_err!(verifier.stack.pop());
              let operand2 = safe_unwrap_err!(verifier.stack.pop());
              if operand2.is_integer() && operand1 == ST::U8 {
                  verifier.push(meter, operand2)?;
              } else {
                  return Err(verifier.error(StatusCode::INTEGER_OP_TYPE_MISMATCH_ERROR, offset));
              }
          }
  
          Bytecode::Or | Bytecode::And => {
              let operand1 = safe_unwrap_err!(verifier.stack.pop());
              let operand2 = safe_unwrap_err!(verifier.stack.pop());
              if operand1 == ST::Bool && operand2 == ST::Bool {
                  verifier.push(meter, ST::Bool)?;
              } else {
                  return Err(verifier.error(StatusCode::BOOLEAN_OP_TYPE_MISMATCH_ERROR, offset));
              }
          }
  
          Bytecode::Not => {
              let operand = safe_unwrap_err!(verifier.stack.pop());
              if operand == ST::Bool {
                  verifier.push(meter, ST::Bool)?;
              } else {
                  return Err(verifier.error(StatusCode::BOOLEAN_OP_TYPE_MISMATCH_ERROR, offset));
              }
          }
  
          Bytecode::Eq | Bytecode::Neq => {
              let operand1 = safe_unwrap_err!(verifier.stack.pop());
              let operand2 = safe_unwrap_err!(verifier.stack.pop());
              if verifier.abilities(&operand1)?.has_drop() && operand1 == operand2 {
                  verifier.push(meter, ST::Bool)?;
              } else {
                  return Err(verifier.error(StatusCode::EQUALITY_OP_TYPE_MISMATCH_ERROR, offset));
              }
          }
  
          Bytecode::Lt | Bytecode::Gt | Bytecode::Le | Bytecode::Ge => {
              let operand1 = safe_unwrap_err!(verifier.stack.pop());
              let operand2 = safe_unwrap_err!(verifier.stack.pop());
              if operand1.is_integer() && operand1 == operand2 {
                  verifier.push(meter, ST::Bool)?
              } else {
                  return Err(verifier.error(StatusCode::INTEGER_OP_TYPE_MISMATCH_ERROR, offset));
              }
          }
  
          Bytecode::MutBorrowGlobalDeprecated(idx) => {
              borrow_global(verifier, meter, offset, true, *idx, &Signature(vec![]))?
          }
  
          Bytecode::MutBorrowGlobalGenericDeprecated(idx) => {
              let struct_inst = verifier.module.struct_instantiation_at( *idx);
              let type_inst = verifier.module.signature_at(struct_inst.type_parameters);
              verifier.charge_tys(meter, &type_inst.0)?;
              borrow_global(verifier, meter, offset, true, struct_inst.def, type_inst)?
          }
  
          Bytecode::ImmBorrowGlobalDeprecated(idx) => {
              borrow_global(verifier, meter, offset, false, *idx, &Signature(vec![]))?
          }
  
          Bytecode::ImmBorrowGlobalGenericDeprecated(idx) => {
              let struct_inst = verifier.module.struct_instantiation_at( *idx);
              let type_inst = verifier.module.signature_at(struct_inst.type_parameters);
              verifier.charge_tys(meter, &type_inst.0)?;
              borrow_global(verifier, meter, offset, false, struct_inst.def, type_inst)?
          }
  
          Bytecode::ExistsDeprecated(idx) => {
              let struct_def = verifier.module.struct_def_at( *idx);
              exists(verifier, meter, offset, struct_def, &Signature(vec![]))?
          }
  
          Bytecode::ExistsGenericDeprecated(idx) => {
              let struct_inst = verifier.module.struct_instantiation_at( *idx);
              let struct_def = verifier.module.struct_def_at(struct_inst.def);
              let type_args = verifier.module.signature_at(struct_inst.type_parameters);
              verifier.charge_tys(meter, &type_args.0)?;
              exists(verifier, meter, offset, struct_def, type_args)?
          }
  
          Bytecode::MoveFromDeprecated(idx) => {
              let struct_def = verifier.module.struct_def_at( *idx);
              move_from(verifier, meter, offset, struct_def, &Signature(vec![]))?
          }
  
          Bytecode::MoveFromGenericDeprecated(idx) => {
              let struct_inst = verifier.module.struct_instantiation_at( *idx);
              let struct_def = verifier.module.struct_def_at(struct_inst.def);
              let type_args = verifier.module.signature_at(struct_inst.type_parameters);
              verifier.charge_tys(meter, &type_args.0)?;
              move_from(verifier, meter, offset, struct_def, type_args)?
          }
  
          Bytecode::MoveToDeprecated(idx) => {
              let struct_def = verifier.module.struct_def_at( *idx);
              move_to(verifier, offset, struct_def, &Signature(vec![]))?
          }
  
          Bytecode::MoveToGenericDeprecated(idx) => {
              let struct_inst = verifier.module.struct_instantiation_at( *idx);
              let struct_def = verifier.module.struct_def_at(struct_inst.def);
              let type_args = verifier.module.signature_at(struct_inst.type_parameters);
              verifier.charge_tys(meter, &type_args.0)?;
              move_to(verifier, offset, struct_def, type_args)?
          }
  
          Bytecode::VecPack(idx, num) => {
              let element_type = &verifier.module.signature_at( *idx).0[0];
              if let Some(num_to_pop) = NonZeroU64::new( *num) {
                  let is_mismatched = verifier
                      .stack
                      .pop_eq_n(num_to_pop)
                      .map(|t| element_type != &t)
                      .unwrap_or(true);
                  if is_mismatched {
                      return Err(verifier.error(StatusCode::TYPE_MISMATCH, offset));
                  }
              }
              verifier.push(meter, ST::Vector(Box::new(element_type.clone())))?;
          }
  
          Bytecode::VecLen(idx) => {
              let operand = safe_unwrap_err!(verifier.stack.pop());
              let declared_element_type = &verifier.module.signature_at( *idx).0[0];
              match get_vector_element_type(operand, false) {
                  Some(derived_element_type) if &derived_element_type == declared_element_type => {
                      verifier.push(meter, ST::U64)?;
                  }
                  _ => return Err(verifier.error(StatusCode::TYPE_MISMATCH, offset)),
              };
          }
  
          Bytecode::VecImmBorrow(idx) => {
              let declared_element_type = &verifier.module.signature_at( *idx).0[0];
              borrow_vector_element(verifier, meter, declared_element_type, offset, false)?
          }
          Bytecode::VecMutBorrow(idx) => {
              let declared_element_type = &verifier.module.signature_at( *idx).0[0];
              borrow_vector_element(verifier, meter, declared_element_type, offset, true)?
          }
  
          Bytecode::VecPushBack(idx) => {
              let operand_elem = safe_unwrap_err!(verifier.stack.pop());
              let operand_vec = safe_unwrap_err!(verifier.stack.pop());
              let declared_element_type = &verifier.module.signature_at( *idx).0[0];
              if declared_element_type != &operand_elem {
                  return Err(verifier.error(StatusCode::TYPE_MISMATCH, offset));
              }
              match get_vector_element_type(operand_vec, true) {
                  Some(derived_element_type) if &derived_element_type == declared_element_type => {}
                  _ => return Err(verifier.error(StatusCode::TYPE_MISMATCH, offset)),
              };
          }
  
          Bytecode::VecPopBack(idx) => {
              let operand_vec = safe_unwrap_err!(verifier.stack.pop());
              let declared_element_type = &verifier.module.signature_at( *idx).0[0];
              match get_vector_element_type(operand_vec, true) {
                  Some(derived_element_type) if &derived_element_type == declared_element_type => {
                      verifier.push(meter, derived_element_type)?;
                  }
                  _ => return Err(verifier.error(StatusCode::TYPE_MISMATCH, offset)),
              };
          }
  
          Bytecode::VecUnpack(idx, num) => {
              let operand_vec = safe_unwrap_err!(verifier.stack.pop());
              let declared_element_type = &verifier.module.signature_at( *idx).0[0];
              if operand_vec != ST::Vector(Box::new(declared_element_type.clone())) {
                  return Err(verifier.error(StatusCode::TYPE_MISMATCH, offset));
              }
              verifier.push_n(meter, declared_element_type.clone(), *num)?;
          }
  
          Bytecode::VecSwap(idx) => {
              let operand_idx2 = safe_unwrap_err!(verifier.stack.pop());
              let operand_idx1 = safe_unwrap_err!(verifier.stack.pop());
              let operand_vec = safe_unwrap_err!(verifier.stack.pop());
              if operand_idx1 != ST::U64 || operand_idx2 != ST::U64 {
                  return Err(verifier.error(StatusCode::TYPE_MISMATCH, offset));
              }
              let declared_element_type = &verifier.module.signature_at( *idx).0[0];
              match get_vector_element_type(operand_vec, true) {
                  Some(derived_element_type) if &derived_element_type == declared_element_type => {}
                  _ => return Err(verifier.error(StatusCode::TYPE_MISMATCH, offset)),
              };
          }
          Bytecode::CastU16 => {
              let operand = safe_unwrap_err!(verifier.stack.pop());
              if !operand.is_integer() {
                  return Err(verifier.error(StatusCode::INTEGER_OP_TYPE_MISMATCH_ERROR, offset));
              }
              verifier.push(meter, ST::U16)?;
          }
          Bytecode::CastU32 => {
              let operand = safe_unwrap_err!(verifier.stack.pop());
              if !operand.is_integer() {
                  return Err(verifier.error(StatusCode::INTEGER_OP_TYPE_MISMATCH_ERROR, offset));
              }
              verifier.push(meter, ST::U32)?;
          }
          Bytecode::CastU256 => {
              let operand = safe_unwrap_err!(verifier.stack.pop());
              if !operand.is_integer() {
                  return Err(verifier.error(StatusCode::INTEGER_OP_TYPE_MISMATCH_ERROR, offset));
              }
              verifier.push(meter, ST::U256)?;
          }
      };
      Ok(())
  }
  *)
  Definition verify_instr (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [ impl_Meter__plus___Sized ], [ verifier; bytecode; offset; meter ] =>
      ltac:(M.monadic
        (let verifier := M.alloc (| verifier |) in
        let bytecode := M.alloc (| bytecode |) in
        let offset := M.alloc (| offset |) in
        let meter := M.alloc (| meter |) in
        M.catch_return (|
          ltac:(M.monadic
            (M.read (|
              let~ _ :=
                M.match_operator (|
                  bytecode,
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (|
                            γ,
                            "move_binary_format::file_format::Bytecode::Pop"
                          |) in
                        let~ operand :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:467 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        let~ abilities :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "abilities",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                operand;
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path "move_bytecode_verifier::absint::FunctionContext",
                                    "type_parameters",
                                    []
                                  |),
                                  [
                                    M.read (|
                                      M.SubPointer.get_struct_record_field (|
                                        M.read (| verifier |),
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                        "function_context"
                                      |)
                                    |)
                                  ]
                                |)
                              ]
                            |)
                          |) in
                        M.match_operator (|
                          M.alloc (| Value.Tuple [] |),
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (let γ :=
                                  M.use
                                    (M.alloc (|
                                      UnOp.not (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::file_format::AbilitySet",
                                            "has_drop",
                                            []
                                          |),
                                          [
                                            M.read (|
                                              M.match_operator (|
                                                M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::ops::try_trait::Try",
                                                      Ty.apply
                                                        (Ty.path "core::result::Result")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_binary_format::file_format::AbilitySet";
                                                          Ty.path
                                                            "move_binary_format::errors::PartialVMError"
                                                        ],
                                                      [],
                                                      "branch",
                                                      []
                                                    |),
                                                    [ M.read (| abilities |) ]
                                                  |)
                                                |),
                                                [
                                                  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.is_constant_or_break_match (|
                                    M.read (| γ |),
                                    Value.Bool true
                                  |) in
                                M.alloc (|
                                  M.never_to_any (|
                                    M.read (|
                                      M.return_ (|
                                        Value.StructTuple
                                          "core::result::Result::Err"
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                "error",
                                                []
                                              |),
                                              [
                                                M.read (| verifier |);
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::POP_WITHOUT_DROP_ABILITY"
                                                  [];
                                                M.read (| offset |)
                                              ]
                                            |)
                                          ]
                                      |)
                                    |)
                                  |)
                                |)));
                            fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (M.find_or_pattern (|
                          γ,
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let γ1_0 :=
                                  M.SubPointer.get_struct_tuple_field (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::BrTrue",
                                    0
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let γ1_0 :=
                                  M.SubPointer.get_struct_tuple_field (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::BrFalse",
                                    0
                                  |) in
                                Value.Tuple []))
                          ],
                          M.closure
                            (fun γ =>
                              ltac:(M.monadic
                                match γ with
                                | [] =>
                                  ltac:(M.monadic
                                    (let~ operand :=
                                      M.copy (|
                                        M.match_operator (|
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.apply
                                                  (Ty.path "move_abstract_stack::AbstractStack")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_binary_format::file_format::SignatureToken"
                                                  ],
                                                "pop",
                                                []
                                              |),
                                              [
                                                M.SubPointer.get_struct_record_field (|
                                                  M.read (| verifier |),
                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "stack"
                                                |)
                                              ]
                                            |)
                                          |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Ok",
                                                    0
                                                  |) in
                                                let x := M.copy (| γ0_0 |) in
                                                x));
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Err",
                                                    0
                                                  |) in
                                                let e := M.copy (| γ0_0 |) in
                                                let~ err :=
                                                  M.alloc (|
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path
                                                          "move_binary_format::errors::PartialVMError",
                                                        "with_message",
                                                        []
                                                      |),
                                                      [
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_binary_format::errors::PartialVMError",
                                                            "new",
                                                            []
                                                          |),
                                                          [
                                                            Value.StructTuple
                                                              "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                              []
                                                          ]
                                                        |);
                                                        M.call_closure (|
                                                          M.get_function (|
                                                            "core::hint::must_use",
                                                            [ Ty.path "alloc::string::String" ]
                                                          |),
                                                          [
                                                            M.read (|
                                                              let~ res :=
                                                                M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_function (|
                                                                      "alloc::fmt::format",
                                                                      []
                                                                    |),
                                                                    [
                                                                      M.call_closure (|
                                                                        M.get_associated_function (|
                                                                          Ty.path
                                                                            "core::fmt::Arguments",
                                                                          "new_v1_formatted",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.read (|
                                                                                  Value.String
                                                                                    "crates/move-bytecode-verifier/src/type_safety.rs:477 "
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Argument",
                                                                                    "new_display",
                                                                                    [
                                                                                      Ty.path
                                                                                        "move_abstract_stack::AbsStackError"
                                                                                    ]
                                                                                  |),
                                                                                  [ e ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Placeholder",
                                                                                    "new",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    Value.Integer
                                                                                      IntegerKind.Usize
                                                                                      0;
                                                                                    Value.UnicodeChar
                                                                                      32;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Alignment::Unknown"
                                                                                      [];
                                                                                    Value.Integer
                                                                                      IntegerKind.U32
                                                                                      4;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      [];
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      []
                                                                                  ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::UnsafeArg",
                                                                              "new",
                                                                              []
                                                                            |),
                                                                            []
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |) in
                                                              res
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) in
                                                M.match_operator (|
                                                  M.alloc (| Value.Tuple [] |),
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let γ :=
                                                          M.use (M.alloc (| Value.Bool true |)) in
                                                        let _ :=
                                                          M.is_constant_or_break_match (|
                                                            M.read (| γ |),
                                                            Value.Bool true
                                                          |) in
                                                        M.alloc (|
                                                          M.never_to_any (|
                                                            M.call_closure (|
                                                              M.get_function (|
                                                                "core::panicking::panic_fmt",
                                                                []
                                                              |),
                                                              [
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.path "core::fmt::Arguments",
                                                                    "new_v1",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.read (|
                                                                            Value.String ""
                                                                          |)
                                                                        ]
                                                                    |);
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::Argument",
                                                                              "new_debug",
                                                                              [
                                                                                Ty.path
                                                                                  "move_binary_format::errors::PartialVMError"
                                                                              ]
                                                                            |),
                                                                            [ err ]
                                                                          |)
                                                                        ]
                                                                    |)
                                                                  ]
                                                                |)
                                                              ]
                                                            |)
                                                          |)
                                                        |)));
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (M.alloc (|
                                                          M.never_to_any (|
                                                            M.read (|
                                                              M.return_ (|
                                                                Value.StructTuple
                                                                  "core::result::Result::Err"
                                                                  [ M.read (| err |) ]
                                                              |)
                                                            |)
                                                          |)
                                                        |)))
                                                  ]
                                                |)))
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.path
                                                        "move_binary_format::file_format::SignatureToken",
                                                      [
                                                        Ty.path
                                                          "move_binary_format::file_format::SignatureToken"
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      operand;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "move_binary_format::file_format::SignatureToken::Bool"
                                                          []
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                            "error",
                                                            []
                                                          |),
                                                          [
                                                            M.read (| verifier |);
                                                            Value.StructTuple
                                                              "move_core_types::vm_status::StatusCode::BR_TYPE_MISMATCH_ERROR"
                                                              [];
                                                            M.read (| offset |)
                                                          ]
                                                        |)
                                                      ]
                                                  |)
                                                |)
                                              |)
                                            |)));
                                        fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                      ]
                                    |)))
                                | _ => M.impossible "wrong number of arguments"
                                end))
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::StLoc",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ operand :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:484 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        M.match_operator (|
                          M.alloc (| Value.Tuple [] |),
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (let γ :=
                                  M.use
                                    (M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "&")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken"
                                            ],
                                          [
                                            Ty.apply
                                              (Ty.path "&")
                                              []
                                              [
                                                Ty.path
                                                  "move_binary_format::file_format::SignatureToken"
                                              ]
                                          ],
                                          "ne",
                                          []
                                        |),
                                        [
                                          M.alloc (| operand |);
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                "local_at",
                                                []
                                              |),
                                              [ M.read (| verifier |); M.read (| M.read (| idx |) |)
                                              ]
                                            |)
                                          |)
                                        ]
                                      |)
                                    |)) in
                                let _ :=
                                  M.is_constant_or_break_match (|
                                    M.read (| γ |),
                                    Value.Bool true
                                  |) in
                                M.alloc (|
                                  M.never_to_any (|
                                    M.read (|
                                      M.return_ (|
                                        Value.StructTuple
                                          "core::result::Result::Err"
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                "error",
                                                []
                                              |),
                                              [
                                                M.read (| verifier |);
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::STLOC_TYPE_MISMATCH_ERROR"
                                                  [];
                                                M.read (| offset |)
                                              ]
                                            |)
                                          ]
                                      |)
                                    |)
                                  |)
                                |)));
                            fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (|
                            γ,
                            "move_binary_format::file_format::Bytecode::Abort"
                          |) in
                        let~ operand :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:491 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        M.match_operator (|
                          M.alloc (| Value.Tuple [] |),
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (let γ :=
                                  M.use
                                    (M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.path "move_binary_format::file_format::SignatureToken",
                                          [
                                            Ty.path
                                              "move_binary_format::file_format::SignatureToken"
                                          ],
                                          "ne",
                                          []
                                        |),
                                        [
                                          operand;
                                          M.alloc (|
                                            Value.StructTuple
                                              "move_binary_format::file_format::SignatureToken::U64"
                                              []
                                          |)
                                        ]
                                      |)
                                    |)) in
                                let _ :=
                                  M.is_constant_or_break_match (|
                                    M.read (| γ |),
                                    Value.Bool true
                                  |) in
                                M.alloc (|
                                  M.never_to_any (|
                                    M.read (|
                                      M.return_ (|
                                        Value.StructTuple
                                          "core::result::Result::Err"
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                "error",
                                                []
                                              |),
                                              [
                                                M.read (| verifier |);
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::ABORT_TYPE_MISMATCH_ERROR"
                                                  [];
                                                M.read (| offset |)
                                              ]
                                            |)
                                          ]
                                      |)
                                    |)
                                  |)
                                |)));
                            fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (|
                            γ,
                            "move_binary_format::file_format::Bytecode::Ret"
                          |) in
                        let~ return_ :=
                          M.alloc (|
                            M.SubPointer.get_struct_tuple_field (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_bytecode_verifier::absint::FunctionContext",
                                  "return_",
                                  []
                                |),
                                [
                                  M.read (|
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "function_context"
                                    |)
                                  |)
                                ]
                              |),
                              "move_binary_format::file_format::Signature",
                              0
                            |)
                          |) in
                        M.use
                          (M.match_operator (|
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::iter::traits::collect::IntoIterator",
                                  Ty.apply
                                    (Ty.path "core::iter::adapters::rev::Rev")
                                    []
                                    [
                                      Ty.apply
                                        (Ty.path "core::slice::iter::Iter")
                                        []
                                        [ Ty.path "move_binary_format::file_format::SignatureToken"
                                        ]
                                    ],
                                  [],
                                  "into_iter",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::iter::traits::iterator::Iterator",
                                      Ty.apply
                                        (Ty.path "core::slice::iter::Iter")
                                        []
                                        [ Ty.path "move_binary_format::file_format::SignatureToken"
                                        ],
                                      [],
                                      "rev",
                                      []
                                    |),
                                    [
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.apply
                                            (Ty.path "slice")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken"
                                            ],
                                          "iter",
                                          []
                                        |),
                                        [
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::ops::deref::Deref",
                                              Ty.apply
                                                (Ty.path "alloc::vec::Vec")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::SignatureToken";
                                                  Ty.path "alloc::alloc::Global"
                                                ],
                                              [],
                                              "deref",
                                              []
                                            |),
                                            [ M.read (| return_ |) ]
                                          |)
                                        ]
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let iter := M.copy (| γ |) in
                                  M.loop (|
                                    ltac:(M.monadic
                                      (let~ _ :=
                                        M.match_operator (|
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_trait_method (|
                                                "core::iter::traits::iterator::Iterator",
                                                Ty.apply
                                                  (Ty.path "core::iter::adapters::rev::Rev")
                                                  []
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::slice::iter::Iter")
                                                      []
                                                      [
                                                        Ty.path
                                                          "move_binary_format::file_format::SignatureToken"
                                                      ]
                                                  ],
                                                [],
                                                "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 return_type := M.copy (| γ0_0 |) in
                                                let~ operand :=
                                                  M.copy (|
                                                    M.match_operator (|
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.apply
                                                              (Ty.path
                                                                "move_abstract_stack::AbstractStack")
                                                              []
                                                              [
                                                                Ty.path
                                                                  "move_binary_format::file_format::SignatureToken"
                                                              ],
                                                            "pop",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_struct_record_field (|
                                                              M.read (| verifier |),
                                                              "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                              "stack"
                                                            |)
                                                          ]
                                                        |)
                                                      |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ0_0 :=
                                                              M.SubPointer.get_struct_tuple_field (|
                                                                γ,
                                                                "core::result::Result::Ok",
                                                                0
                                                              |) in
                                                            let x := M.copy (| γ0_0 |) in
                                                            x));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ0_0 :=
                                                              M.SubPointer.get_struct_tuple_field (|
                                                                γ,
                                                                "core::result::Result::Err",
                                                                0
                                                              |) in
                                                            let e := M.copy (| γ0_0 |) in
                                                            let~ err :=
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError",
                                                                    "with_message",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "move_binary_format::errors::PartialVMError",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.StructTuple
                                                                          "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                                          []
                                                                      ]
                                                                    |);
                                                                    M.call_closure (|
                                                                      M.get_function (|
                                                                        "core::hint::must_use",
                                                                        [
                                                                          Ty.path
                                                                            "alloc::string::String"
                                                                        ]
                                                                      |),
                                                                      [
                                                                        M.read (|
                                                                          let~ res :=
                                                                            M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_function (|
                                                                                  "alloc::fmt::format",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  M.call_closure (|
                                                                                    M.get_associated_function (|
                                                                                      Ty.path
                                                                                        "core::fmt::Arguments",
                                                                                      "new_v1_formatted",
                                                                                      []
                                                                                    |),
                                                                                    [
                                                                                      M.alloc (|
                                                                                        Value.Array
                                                                                          [
                                                                                            M.read (|
                                                                                              Value.String
                                                                                                "crates/move-bytecode-verifier/src/type_safety.rs:500 "
                                                                                            |)
                                                                                          ]
                                                                                      |);
                                                                                      M.alloc (|
                                                                                        Value.Array
                                                                                          [
                                                                                            M.call_closure (|
                                                                                              M.get_associated_function (|
                                                                                                Ty.path
                                                                                                  "core::fmt::rt::Argument",
                                                                                                "new_display",
                                                                                                [
                                                                                                  Ty.path
                                                                                                    "move_abstract_stack::AbsStackError"
                                                                                                ]
                                                                                              |),
                                                                                              [ e ]
                                                                                            |)
                                                                                          ]
                                                                                      |);
                                                                                      M.alloc (|
                                                                                        Value.Array
                                                                                          [
                                                                                            M.call_closure (|
                                                                                              M.get_associated_function (|
                                                                                                Ty.path
                                                                                                  "core::fmt::rt::Placeholder",
                                                                                                "new",
                                                                                                []
                                                                                              |),
                                                                                              [
                                                                                                Value.Integer
                                                                                                  IntegerKind.Usize
                                                                                                  0;
                                                                                                Value.UnicodeChar
                                                                                                  32;
                                                                                                Value.StructTuple
                                                                                                  "core::fmt::rt::Alignment::Unknown"
                                                                                                  [];
                                                                                                Value.Integer
                                                                                                  IntegerKind.U32
                                                                                                  4;
                                                                                                Value.StructTuple
                                                                                                  "core::fmt::rt::Count::Implied"
                                                                                                  [];
                                                                                                Value.StructTuple
                                                                                                  "core::fmt::rt::Count::Implied"
                                                                                                  []
                                                                                              ]
                                                                                            |)
                                                                                          ]
                                                                                      |);
                                                                                      M.call_closure (|
                                                                                        M.get_associated_function (|
                                                                                          Ty.path
                                                                                            "core::fmt::rt::UnsafeArg",
                                                                                          "new",
                                                                                          []
                                                                                        |),
                                                                                        []
                                                                                      |)
                                                                                    ]
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |) in
                                                                          res
                                                                        |)
                                                                      ]
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (| Value.Tuple [] |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ :=
                                                                      M.use
                                                                        (M.alloc (|
                                                                          Value.Bool true
                                                                        |)) in
                                                                    let _ :=
                                                                      M.is_constant_or_break_match (|
                                                                        M.read (| γ |),
                                                                        Value.Bool true
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.never_to_any (|
                                                                        M.call_closure (|
                                                                          M.get_function (|
                                                                            "core::panicking::panic_fmt",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.call_closure (|
                                                                              M.get_associated_function (|
                                                                                Ty.path
                                                                                  "core::fmt::Arguments",
                                                                                "new_v1",
                                                                                []
                                                                              |),
                                                                              [
                                                                                M.alloc (|
                                                                                  Value.Array
                                                                                    [
                                                                                      M.read (|
                                                                                        Value.String
                                                                                          ""
                                                                                      |)
                                                                                    ]
                                                                                |);
                                                                                M.alloc (|
                                                                                  Value.Array
                                                                                    [
                                                                                      M.call_closure (|
                                                                                        M.get_associated_function (|
                                                                                          Ty.path
                                                                                            "core::fmt::rt::Argument",
                                                                                          "new_debug",
                                                                                          [
                                                                                            Ty.path
                                                                                              "move_binary_format::errors::PartialVMError"
                                                                                          ]
                                                                                        |),
                                                                                        [ err ]
                                                                                      |)
                                                                                    ]
                                                                                |)
                                                                              ]
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (M.alloc (|
                                                                      M.never_to_any (|
                                                                        M.read (|
                                                                          M.return_ (|
                                                                            Value.StructTuple
                                                                              "core::result::Result::Err"
                                                                              [ M.read (| err |) ]
                                                                          |)
                                                                        |)
                                                                      |)
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)
                                                  |) in
                                                M.match_operator (|
                                                  M.alloc (| Value.Tuple [] |),
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let γ :=
                                                          M.use
                                                            (M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "&")
                                                                    []
                                                                    [
                                                                      Ty.path
                                                                        "move_binary_format::file_format::SignatureToken"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path "&")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "move_binary_format::file_format::SignatureToken"
                                                                      ]
                                                                  ],
                                                                  "ne",
                                                                  []
                                                                |),
                                                                [ M.alloc (| operand |); return_type
                                                                ]
                                                              |)
                                                            |)) in
                                                        let _ :=
                                                          M.is_constant_or_break_match (|
                                                            M.read (| γ |),
                                                            Value.Bool true
                                                          |) in
                                                        M.alloc (|
                                                          M.never_to_any (|
                                                            M.read (|
                                                              M.return_ (|
                                                                Value.StructTuple
                                                                  "core::result::Result::Err"
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                                        "error",
                                                                        []
                                                                      |),
                                                                      [
                                                                        M.read (| verifier |);
                                                                        Value.StructTuple
                                                                          "move_core_types::vm_status::StatusCode::RET_TYPE_MISMATCH_ERROR"
                                                                          [];
                                                                        M.read (| offset |)
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |)
                                                            |)
                                                          |)
                                                        |)));
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (M.alloc (| Value.Tuple [] |)))
                                                  ]
                                                |)))
                                          ]
                                        |) in
                                      M.alloc (| Value.Tuple [] |)))
                                  |)))
                            ]
                          |))));
                    fun γ =>
                      ltac:(M.monadic
                        (M.find_or_pattern (|
                          γ,
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let γ1_0 :=
                                  M.SubPointer.get_struct_tuple_field (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::Branch",
                                    0
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::Nop"
                                  |) in
                                Value.Tuple []))
                          ],
                          M.closure
                            (fun γ =>
                              ltac:(M.monadic
                                match γ with
                                | [] => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                | _ => M.impossible "wrong number of arguments"
                                end))
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (|
                            γ,
                            "move_binary_format::file_format::Bytecode::FreezeRef"
                          |) in
                        let~ operand :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:510 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        M.match_operator (|
                          operand,
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (let γ0_0 :=
                                  M.SubPointer.get_struct_tuple_field (|
                                    γ,
                                    "move_binary_format::file_format::SignatureToken::MutableReference",
                                    0
                                  |) in
                                let inner := M.copy (| γ0_0 |) 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_associated_function (|
                                            Ty.path
                                              "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                            "push",
                                            [ impl_Meter__plus___Sized ]
                                          |),
                                          [
                                            M.read (| verifier |);
                                            M.read (| meter |);
                                            Value.StructTuple
                                              "move_binary_format::file_format::SignatureToken::Reference"
                                              [ M.read (| inner |) ]
                                          ]
                                        |)
                                      ]
                                    |)
                                  |),
                                  [
                                    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))
                                  ]
                                |)));
                            fun γ =>
                              ltac:(M.monadic
                                (M.alloc (|
                                  M.never_to_any (|
                                    M.read (|
                                      M.return_ (|
                                        Value.StructTuple
                                          "core::result::Result::Err"
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                "error",
                                                []
                                              |),
                                              [
                                                M.read (| verifier |);
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::FREEZEREF_TYPE_MISMATCH_ERROR"
                                                  [];
                                                M.read (| offset |)
                                              ]
                                            |)
                                          ]
                                      |)
                                    |)
                                  |)
                                |)))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::MutBorrowField",
                            0
                          |) in
                        let field_handle_index := M.alloc (| γ1_0 |) 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_function (|
                                    "move_bytecode_verifier::type_safety::borrow_field",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| offset |);
                                    Value.Bool true;
                                    M.read (| M.read (| field_handle_index |) |);
                                    M.alloc (|
                                      Value.StructTuple
                                        "move_binary_format::file_format::Signature"
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.apply
                                                (Ty.path "alloc::vec::Vec")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::SignatureToken";
                                                  Ty.path "alloc::alloc::Global"
                                                ],
                                              "new",
                                              []
                                            |),
                                            []
                                          |)
                                        ]
                                    |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::MutBorrowFieldGeneric",
                            0
                          |) in
                        let field_inst_index := M.alloc (| γ1_0 |) in
                        let~ field_inst :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "field_instantiation_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| field_inst_index |) |)
                              ]
                            |)
                          |) in
                        let~ type_inst :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "signature_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| field_inst |),
                                    "move_binary_format::file_format::FieldInstantiation",
                                    "type_parameters"
                                  |)
                                |)
                              ]
                            |)
                          |) 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_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "charge_tys",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::ops::deref::Deref",
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken";
                                              Ty.path "alloc::alloc::Global"
                                            ],
                                          [],
                                          "deref",
                                          []
                                        |),
                                        [
                                          M.SubPointer.get_struct_tuple_field (|
                                            M.read (| type_inst |),
                                            "move_binary_format::file_format::Signature",
                                            0
                                          |)
                                        ]
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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_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_function (|
                                    "move_bytecode_verifier::type_safety::borrow_field",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| offset |);
                                    Value.Bool true;
                                    M.read (|
                                      M.SubPointer.get_struct_record_field (|
                                        M.read (| field_inst |),
                                        "move_binary_format::file_format::FieldInstantiation",
                                        "handle"
                                      |)
                                    |);
                                    M.read (| type_inst |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::ImmBorrowField",
                            0
                          |) in
                        let field_handle_index := M.alloc (| γ1_0 |) 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_function (|
                                    "move_bytecode_verifier::type_safety::borrow_field",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| offset |);
                                    Value.Bool false;
                                    M.read (| M.read (| field_handle_index |) |);
                                    M.alloc (|
                                      Value.StructTuple
                                        "move_binary_format::file_format::Signature"
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.apply
                                                (Ty.path "alloc::vec::Vec")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::SignatureToken";
                                                  Ty.path "alloc::alloc::Global"
                                                ],
                                              "new",
                                              []
                                            |),
                                            []
                                          |)
                                        ]
                                    |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::ImmBorrowFieldGeneric",
                            0
                          |) in
                        let field_inst_index := M.alloc (| γ1_0 |) in
                        let~ field_inst :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "field_instantiation_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| field_inst_index |) |)
                              ]
                            |)
                          |) in
                        let~ type_inst :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "signature_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| field_inst |),
                                    "move_binary_format::file_format::FieldInstantiation",
                                    "type_parameters"
                                  |)
                                |)
                              ]
                            |)
                          |) 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_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "charge_tys",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::ops::deref::Deref",
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken";
                                              Ty.path "alloc::alloc::Global"
                                            ],
                                          [],
                                          "deref",
                                          []
                                        |),
                                        [
                                          M.SubPointer.get_struct_tuple_field (|
                                            M.read (| type_inst |),
                                            "move_binary_format::file_format::Signature",
                                            0
                                          |)
                                        ]
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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_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_function (|
                                    "move_bytecode_verifier::type_safety::borrow_field",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| offset |);
                                    Value.Bool false;
                                    M.read (|
                                      M.SubPointer.get_struct_record_field (|
                                        M.read (| field_inst |),
                                        "move_binary_format::file_format::FieldInstantiation",
                                        "handle"
                                      |)
                                    |);
                                    M.read (| type_inst |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::LdU8",
                            0
                          |) in
                        let~ _ :=
                          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_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "push",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      Value.StructTuple
                                        "move_binary_format::file_format::SignatureToken::U8"
                                        []
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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.alloc (| Value.Tuple [] |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::LdU16",
                            0
                          |) in
                        let~ _ :=
                          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_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "push",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      Value.StructTuple
                                        "move_binary_format::file_format::SignatureToken::U16"
                                        []
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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.alloc (| Value.Tuple [] |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::LdU32",
                            0
                          |) in
                        let~ _ :=
                          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_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "push",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      Value.StructTuple
                                        "move_binary_format::file_format::SignatureToken::U32"
                                        []
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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.alloc (| Value.Tuple [] |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::LdU64",
                            0
                          |) in
                        let~ _ :=
                          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_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "push",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      Value.StructTuple
                                        "move_binary_format::file_format::SignatureToken::U64"
                                        []
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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.alloc (| Value.Tuple [] |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::LdU128",
                            0
                          |) in
                        let~ _ :=
                          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_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "push",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      Value.StructTuple
                                        "move_binary_format::file_format::SignatureToken::U128"
                                        []
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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.alloc (| Value.Tuple [] |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::LdU256",
                            0
                          |) in
                        let~ _ :=
                          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_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "push",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      Value.StructTuple
                                        "move_binary_format::file_format::SignatureToken::U256"
                                        []
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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.alloc (| Value.Tuple [] |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::LdConst",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ signature :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "core::clone::Clone",
                                Ty.path "move_binary_format::file_format::SignatureToken",
                                [],
                                "clone",
                                []
                              |),
                              [
                                M.SubPointer.get_struct_record_field (|
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::file_format::CompiledModule",
                                      "constant_at",
                                      []
                                    |),
                                    [
                                      M.read (|
                                        M.SubPointer.get_struct_record_field (|
                                          M.read (| verifier |),
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                          "module"
                                        |)
                                      |);
                                      M.read (| M.read (| idx |) |)
                                    ]
                                  |),
                                  "move_binary_format::file_format::Constant",
                                  "type_"
                                |)
                              ]
                            |)
                          |) 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_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "push",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      M.read (| signature |)
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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.alloc (| Value.Tuple [] |)));
                    fun γ =>
                      ltac:(M.monadic
                        (M.find_or_pattern (|
                          γ,
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::LdTrue"
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::LdFalse"
                                  |) in
                                Value.Tuple []))
                          ],
                          M.closure
                            (fun γ =>
                              ltac:(M.monadic
                                match γ with
                                | [] =>
                                  ltac:(M.monadic
                                    (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_associated_function (|
                                                  Ty.path
                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "push",
                                                  [ impl_Meter__plus___Sized ]
                                                |),
                                                [
                                                  M.read (| verifier |);
                                                  M.read (| meter |);
                                                  Value.StructTuple
                                                    "move_binary_format::file_format::SignatureToken::Bool"
                                                    []
                                                ]
                                              |)
                                            ]
                                          |)
                                        |),
                                        [
                                          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.alloc (| Value.Tuple [] |)))
                                | _ => M.impossible "wrong number of arguments"
                                end))
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::CopyLoc",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ local_signature :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "core::clone::Clone",
                                Ty.path "move_binary_format::file_format::SignatureToken",
                                [],
                                "clone",
                                []
                              |),
                              [
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "local_at",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| M.read (| idx |) |) ]
                                |)
                              ]
                            |)
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ :=
                                    M.use
                                      (M.alloc (|
                                        UnOp.not (|
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "move_binary_format::file_format::AbilitySet",
                                              "has_copy",
                                              []
                                            |),
                                            [
                                              M.read (|
                                                M.match_operator (|
                                                  M.alloc (|
                                                    M.call_closure (|
                                                      M.get_trait_method (|
                                                        "core::ops::try_trait::Try",
                                                        Ty.apply
                                                          (Ty.path "core::result::Result")
                                                          []
                                                          [
                                                            Ty.path
                                                              "move_binary_format::file_format::AbilitySet";
                                                            Ty.path
                                                              "move_binary_format::errors::PartialVMError"
                                                          ],
                                                        [],
                                                        "branch",
                                                        []
                                                      |),
                                                      [
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_binary_format::file_format::CompiledModule",
                                                            "abilities",
                                                            []
                                                          |),
                                                          [
                                                            M.read (|
                                                              M.SubPointer.get_struct_record_field (|
                                                                M.read (| verifier |),
                                                                "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                                "module"
                                                              |)
                                                            |);
                                                            local_signature;
                                                            M.call_closure (|
                                                              M.get_associated_function (|
                                                                Ty.path
                                                                  "move_bytecode_verifier::absint::FunctionContext",
                                                                "type_parameters",
                                                                []
                                                              |),
                                                              [
                                                                M.read (|
                                                                  M.SubPointer.get_struct_record_field (|
                                                                    M.read (| verifier |),
                                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                                    "function_context"
                                                                  |)
                                                                |)
                                                              ]
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |),
                                                  [
                                                    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.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path
                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "error",
                                                  []
                                                |),
                                                [
                                                  M.read (| verifier |);
                                                  Value.StructTuple
                                                    "move_core_types::vm_status::StatusCode::COPYLOC_WITHOUT_COPY_ABILITY"
                                                    [];
                                                  M.read (| offset |)
                                                ]
                                              |)
                                            ]
                                        |)
                                      |)
                                    |)
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) 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_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "push",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| local_signature |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::MoveLoc",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ local_signature :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "core::clone::Clone",
                                Ty.path "move_binary_format::file_format::SignatureToken",
                                [],
                                "clone",
                                []
                              |),
                              [
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "local_at",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| M.read (| idx |) |) ]
                                |)
                              ]
                            |)
                          |) 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_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "push",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| local_signature |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::MutBorrowLoc",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) 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_function (|
                                    "move_bytecode_verifier::type_safety::borrow_loc",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| offset |);
                                    Value.Bool true;
                                    M.read (| M.read (| idx |) |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::ImmBorrowLoc",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) 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_function (|
                                    "move_bytecode_verifier::type_safety::borrow_loc",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| offset |);
                                    Value.Bool false;
                                    M.read (| M.read (| idx |) |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::Call",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ function_handle :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "function_handle_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| idx |) |)
                              ]
                            |)
                          |) 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_function (|
                                    "move_bytecode_verifier::type_safety::call",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| offset |);
                                    M.read (| function_handle |);
                                    M.alloc (|
                                      Value.StructTuple
                                        "move_binary_format::file_format::Signature"
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.apply
                                                (Ty.path "alloc::vec::Vec")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::SignatureToken";
                                                  Ty.path "alloc::alloc::Global"
                                                ],
                                              "new",
                                              []
                                            |),
                                            []
                                          |)
                                        ]
                                    |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::CallGeneric",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ func_inst :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "function_instantiation_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| idx |) |)
                              ]
                            |)
                          |) in
                        let~ func_handle :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "function_handle_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| func_inst |),
                                    "move_binary_format::file_format::FunctionInstantiation",
                                    "handle"
                                  |)
                                |)
                              ]
                            |)
                          |) in
                        let~ type_args :=
                          M.alloc (|
                            M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::file_format::CompiledModule",
                                  "signature_at",
                                  []
                                |),
                                [
                                  M.read (|
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "module"
                                    |)
                                  |);
                                  M.read (|
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| func_inst |),
                                      "move_binary_format::file_format::FunctionInstantiation",
                                      "type_parameters"
                                    |)
                                  |)
                                ]
                              |)
                            |)
                          |) 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_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "charge_tys",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::ops::deref::Deref",
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken";
                                              Ty.path "alloc::alloc::Global"
                                            ],
                                          [],
                                          "deref",
                                          []
                                        |),
                                        [
                                          M.SubPointer.get_struct_tuple_field (|
                                            M.read (| M.read (| type_args |) |),
                                            "move_binary_format::file_format::Signature",
                                            0
                                          |)
                                        ]
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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_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_function (|
                                    "move_bytecode_verifier::type_safety::call",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| offset |);
                                    M.read (| func_handle |);
                                    M.read (| M.read (| type_args |) |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::Pack",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ struct_definition :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "struct_def_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| idx |) |)
                              ]
                            |)
                          |) 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_function (|
                                    "move_bytecode_verifier::type_safety::pack",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| offset |);
                                    M.read (| struct_definition |);
                                    M.alloc (|
                                      Value.StructTuple
                                        "move_binary_format::file_format::Signature"
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.apply
                                                (Ty.path "alloc::vec::Vec")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::SignatureToken";
                                                  Ty.path "alloc::alloc::Global"
                                                ],
                                              "new",
                                              []
                                            |),
                                            []
                                          |)
                                        ]
                                    |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::PackGeneric",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ struct_inst :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "struct_instantiation_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| idx |) |)
                              ]
                            |)
                          |) in
                        let~ struct_def :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "struct_def_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| struct_inst |),
                                    "move_binary_format::file_format::StructDefInstantiation",
                                    "def"
                                  |)
                                |)
                              ]
                            |)
                          |) in
                        let~ type_args :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "signature_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| struct_inst |),
                                    "move_binary_format::file_format::StructDefInstantiation",
                                    "type_parameters"
                                  |)
                                |)
                              ]
                            |)
                          |) 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_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "charge_tys",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::ops::deref::Deref",
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken";
                                              Ty.path "alloc::alloc::Global"
                                            ],
                                          [],
                                          "deref",
                                          []
                                        |),
                                        [
                                          M.SubPointer.get_struct_tuple_field (|
                                            M.read (| type_args |),
                                            "move_binary_format::file_format::Signature",
                                            0
                                          |)
                                        ]
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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_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_function (|
                                    "move_bytecode_verifier::type_safety::pack",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| offset |);
                                    M.read (| struct_def |);
                                    M.read (| type_args |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::Unpack",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ struct_definition :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "struct_def_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| idx |) |)
                              ]
                            |)
                          |) 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_function (|
                                    "move_bytecode_verifier::type_safety::unpack",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| offset |);
                                    M.read (| struct_definition |);
                                    M.alloc (|
                                      Value.StructTuple
                                        "move_binary_format::file_format::Signature"
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.apply
                                                (Ty.path "alloc::vec::Vec")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::SignatureToken";
                                                  Ty.path "alloc::alloc::Global"
                                                ],
                                              "new",
                                              []
                                            |),
                                            []
                                          |)
                                        ]
                                    |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::UnpackGeneric",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ struct_inst :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "struct_instantiation_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| idx |) |)
                              ]
                            |)
                          |) in
                        let~ struct_def :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "struct_def_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| struct_inst |),
                                    "move_binary_format::file_format::StructDefInstantiation",
                                    "def"
                                  |)
                                |)
                              ]
                            |)
                          |) in
                        let~ type_args :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "signature_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| struct_inst |),
                                    "move_binary_format::file_format::StructDefInstantiation",
                                    "type_parameters"
                                  |)
                                |)
                              ]
                            |)
                          |) 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_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "charge_tys",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::ops::deref::Deref",
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken";
                                              Ty.path "alloc::alloc::Global"
                                            ],
                                          [],
                                          "deref",
                                          []
                                        |),
                                        [
                                          M.SubPointer.get_struct_tuple_field (|
                                            M.read (| type_args |),
                                            "move_binary_format::file_format::Signature",
                                            0
                                          |)
                                        ]
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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_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_function (|
                                    "move_bytecode_verifier::type_safety::unpack",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| offset |);
                                    M.read (| struct_def |);
                                    M.read (| type_args |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (|
                            γ,
                            "move_binary_format::file_format::Bytecode::ReadRef"
                          |) in
                        let~ operand :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:658 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        M.match_operator (|
                          operand,
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (M.find_or_pattern (|
                                  γ,
                                  [
                                    fun γ =>
                                      ltac:(M.monadic
                                        (let γ0_0 :=
                                          M.SubPointer.get_struct_tuple_field (|
                                            γ,
                                            "move_binary_format::file_format::SignatureToken::Reference",
                                            0
                                          |) in
                                        let inner := M.copy (| γ0_0 |) in
                                        Value.Tuple [ inner ]));
                                    fun γ =>
                                      ltac:(M.monadic
                                        (let γ0_0 :=
                                          M.SubPointer.get_struct_tuple_field (|
                                            γ,
                                            "move_binary_format::file_format::SignatureToken::MutableReference",
                                            0
                                          |) in
                                        let inner := M.copy (| γ0_0 |) in
                                        Value.Tuple [ inner ]))
                                  ],
                                  M.closure
                                    (fun γ =>
                                      ltac:(M.monadic
                                        match γ with
                                        | [ inner ] =>
                                          ltac:(M.monadic
                                            (let~ _ :=
                                              M.match_operator (|
                                                M.alloc (| Value.Tuple [] |),
                                                [
                                                  fun γ =>
                                                    ltac:(M.monadic
                                                      (let γ :=
                                                        M.use
                                                          (M.alloc (|
                                                            UnOp.not (|
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "move_binary_format::file_format::AbilitySet",
                                                                  "has_copy",
                                                                  []
                                                                |),
                                                                [
                                                                  M.read (|
                                                                    M.match_operator (|
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::ops::try_trait::Try",
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "core::result::Result")
                                                                              []
                                                                              [
                                                                                Ty.path
                                                                                  "move_binary_format::file_format::AbilitySet";
                                                                                Ty.path
                                                                                  "move_binary_format::errors::PartialVMError"
                                                                              ],
                                                                            [],
                                                                            "branch",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.call_closure (|
                                                                              M.get_associated_function (|
                                                                                Ty.path
                                                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                                                "abilities",
                                                                                []
                                                                              |),
                                                                              [
                                                                                M.read (|
                                                                                  verifier
                                                                                |);
                                                                                M.read (| inner |)
                                                                              ]
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |),
                                                                      [
                                                                        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.is_constant_or_break_match (|
                                                          M.read (| γ |),
                                                          Value.Bool true
                                                        |) in
                                                      M.alloc (|
                                                        M.never_to_any (|
                                                          M.read (|
                                                            M.return_ (|
                                                              Value.StructTuple
                                                                "core::result::Result::Err"
                                                                [
                                                                  M.call_closure (|
                                                                    M.get_associated_function (|
                                                                      Ty.path
                                                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                                      "error",
                                                                      []
                                                                    |),
                                                                    [
                                                                      M.read (| verifier |);
                                                                      Value.StructTuple
                                                                        "move_core_types::vm_status::StatusCode::READREF_WITHOUT_COPY_ABILITY"
                                                                        [];
                                                                      M.read (| offset |)
                                                                    ]
                                                                  |)
                                                                ]
                                                            |)
                                                          |)
                                                        |)
                                                      |)));
                                                  fun γ =>
                                                    ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                                ]
                                              |) in
                                            let~ _ :=
                                              M.match_operator (|
                                                M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::ops::try_trait::Try",
                                                      Ty.apply
                                                        (Ty.path "core::result::Result")
                                                        []
                                                        [
                                                          Ty.tuple [];
                                                          Ty.path
                                                            "move_binary_format::errors::PartialVMError"
                                                        ],
                                                      [],
                                                      "branch",
                                                      []
                                                    |),
                                                    [
                                                      M.call_closure (|
                                                        M.get_associated_function (|
                                                          Ty.path
                                                            "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                          "push",
                                                          [ impl_Meter__plus___Sized ]
                                                        |),
                                                        [
                                                          M.read (| verifier |);
                                                          M.read (| meter |);
                                                          M.read (| M.read (| inner |) |)
                                                        ]
                                                      |)
                                                    ]
                                                  |)
                                                |),
                                                [
                                                  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.alloc (| Value.Tuple [] |)))
                                        | _ => M.impossible "wrong number of arguments"
                                        end))
                                |)));
                            fun γ =>
                              ltac:(M.monadic
                                (M.alloc (|
                                  M.never_to_any (|
                                    M.read (|
                                      M.return_ (|
                                        Value.StructTuple
                                          "core::result::Result::Err"
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                "error",
                                                []
                                              |),
                                              [
                                                M.read (| verifier |);
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::READREF_TYPE_MISMATCH_ERROR"
                                                  [];
                                                M.read (| offset |)
                                              ]
                                            |)
                                          ]
                                      |)
                                    |)
                                  |)
                                |)))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (|
                            γ,
                            "move_binary_format::file_format::Bytecode::WriteRef"
                          |) in
                        let~ ref_operand :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:673 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        let~ val_operand :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:674 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        let~ ref_inner_signature :=
                          M.copy (|
                            M.match_operator (|
                              ref_operand,
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "move_binary_format::file_format::SignatureToken::MutableReference",
                                        0
                                      |) in
                                    let inner := M.copy (| γ0_0 |) in
                                    M.read (| inner |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (M.alloc (|
                                      M.never_to_any (|
                                        M.read (|
                                          M.return_ (|
                                            Value.StructTuple
                                              "core::result::Result::Err"
                                              [
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path
                                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                    "error",
                                                    []
                                                  |),
                                                  [
                                                    M.read (| verifier |);
                                                    Value.StructTuple
                                                      "move_core_types::vm_status::StatusCode::WRITEREF_NO_MUTABLE_REFERENCE_ERROR"
                                                      [];
                                                    M.read (| offset |)
                                                  ]
                                                |)
                                              ]
                                          |)
                                        |)
                                      |)
                                    |)))
                              ]
                            |)
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ :=
                                    M.use
                                      (M.alloc (|
                                        UnOp.not (|
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "move_binary_format::file_format::AbilitySet",
                                              "has_drop",
                                              []
                                            |),
                                            [
                                              M.read (|
                                                M.match_operator (|
                                                  M.alloc (|
                                                    M.call_closure (|
                                                      M.get_trait_method (|
                                                        "core::ops::try_trait::Try",
                                                        Ty.apply
                                                          (Ty.path "core::result::Result")
                                                          []
                                                          [
                                                            Ty.path
                                                              "move_binary_format::file_format::AbilitySet";
                                                            Ty.path
                                                              "move_binary_format::errors::PartialVMError"
                                                          ],
                                                        [],
                                                        "branch",
                                                        []
                                                      |),
                                                      [
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                            "abilities",
                                                            []
                                                          |),
                                                          [
                                                            M.read (| verifier |);
                                                            ref_inner_signature
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |),
                                                  [
                                                    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.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path
                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "error",
                                                  []
                                                |),
                                                [
                                                  M.read (| verifier |);
                                                  Value.StructTuple
                                                    "move_core_types::vm_status::StatusCode::WRITEREF_WITHOUT_DROP_ABILITY"
                                                    [];
                                                  M.read (| offset |)
                                                ]
                                              |)
                                            ]
                                        |)
                                      |)
                                    |)
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) in
                        M.match_operator (|
                          M.alloc (| Value.Tuple [] |),
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (let γ :=
                                  M.use
                                    (M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.path "move_binary_format::file_format::SignatureToken",
                                          [
                                            Ty.path
                                              "move_binary_format::file_format::SignatureToken"
                                          ],
                                          "ne",
                                          []
                                        |),
                                        [ val_operand; ref_inner_signature ]
                                      |)
                                    |)) in
                                let _ :=
                                  M.is_constant_or_break_match (|
                                    M.read (| γ |),
                                    Value.Bool true
                                  |) in
                                M.alloc (|
                                  M.never_to_any (|
                                    M.read (|
                                      M.return_ (|
                                        Value.StructTuple
                                          "core::result::Result::Err"
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                "error",
                                                []
                                              |),
                                              [
                                                M.read (| verifier |);
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::WRITEREF_TYPE_MISMATCH_ERROR"
                                                  [];
                                                M.read (| offset |)
                                              ]
                                            |)
                                          ]
                                      |)
                                    |)
                                  |)
                                |)));
                            fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (|
                            γ,
                            "move_binary_format::file_format::Bytecode::CastU8"
                          |) in
                        let~ operand :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:693 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ :=
                                    M.use
                                      (M.alloc (|
                                        UnOp.not (|
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken",
                                              "is_integer",
                                              []
                                            |),
                                            [ operand ]
                                          |)
                                        |)
                                      |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path
                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "error",
                                                  []
                                                |),
                                                [
                                                  M.read (| verifier |);
                                                  Value.StructTuple
                                                    "move_core_types::vm_status::StatusCode::INTEGER_OP_TYPE_MISMATCH_ERROR"
                                                    [];
                                                  M.read (| offset |)
                                                ]
                                              |)
                                            ]
                                        |)
                                      |)
                                    |)
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::ops::try_trait::Try",
                                  Ty.apply
                                    (Ty.path "core::result::Result")
                                    []
                                    [
                                      Ty.tuple [];
                                      Ty.path "move_binary_format::errors::PartialVMError"
                                    ],
                                  [],
                                  "branch",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "push",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      Value.StructTuple
                                        "move_binary_format::file_format::SignatureToken::U8"
                                        []
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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.alloc (| Value.Tuple [] |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (|
                            γ,
                            "move_binary_format::file_format::Bytecode::CastU64"
                          |) in
                        let~ operand :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:700 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ :=
                                    M.use
                                      (M.alloc (|
                                        UnOp.not (|
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken",
                                              "is_integer",
                                              []
                                            |),
                                            [ operand ]
                                          |)
                                        |)
                                      |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path
                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "error",
                                                  []
                                                |),
                                                [
                                                  M.read (| verifier |);
                                                  Value.StructTuple
                                                    "move_core_types::vm_status::StatusCode::INTEGER_OP_TYPE_MISMATCH_ERROR"
                                                    [];
                                                  M.read (| offset |)
                                                ]
                                              |)
                                            ]
                                        |)
                                      |)
                                    |)
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::ops::try_trait::Try",
                                  Ty.apply
                                    (Ty.path "core::result::Result")
                                    []
                                    [
                                      Ty.tuple [];
                                      Ty.path "move_binary_format::errors::PartialVMError"
                                    ],
                                  [],
                                  "branch",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "push",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      Value.StructTuple
                                        "move_binary_format::file_format::SignatureToken::U64"
                                        []
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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.alloc (| Value.Tuple [] |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (|
                            γ,
                            "move_binary_format::file_format::Bytecode::CastU128"
                          |) in
                        let~ operand :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:707 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ :=
                                    M.use
                                      (M.alloc (|
                                        UnOp.not (|
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken",
                                              "is_integer",
                                              []
                                            |),
                                            [ operand ]
                                          |)
                                        |)
                                      |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path
                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "error",
                                                  []
                                                |),
                                                [
                                                  M.read (| verifier |);
                                                  Value.StructTuple
                                                    "move_core_types::vm_status::StatusCode::INTEGER_OP_TYPE_MISMATCH_ERROR"
                                                    [];
                                                  M.read (| offset |)
                                                ]
                                              |)
                                            ]
                                        |)
                                      |)
                                    |)
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::ops::try_trait::Try",
                                  Ty.apply
                                    (Ty.path "core::result::Result")
                                    []
                                    [
                                      Ty.tuple [];
                                      Ty.path "move_binary_format::errors::PartialVMError"
                                    ],
                                  [],
                                  "branch",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "push",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      Value.StructTuple
                                        "move_binary_format::file_format::SignatureToken::U128"
                                        []
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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.alloc (| Value.Tuple [] |)));
                    fun γ =>
                      ltac:(M.monadic
                        (M.find_or_pattern (|
                          γ,
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::Add"
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::Sub"
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::Mul"
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::Mod"
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::Div"
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::BitOr"
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::BitAnd"
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::Xor"
                                  |) in
                                Value.Tuple []))
                          ],
                          M.closure
                            (fun γ =>
                              ltac:(M.monadic
                                match γ with
                                | [] =>
                                  ltac:(M.monadic
                                    (let~ operand1 :=
                                      M.copy (|
                                        M.match_operator (|
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.apply
                                                  (Ty.path "move_abstract_stack::AbstractStack")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_binary_format::file_format::SignatureToken"
                                                  ],
                                                "pop",
                                                []
                                              |),
                                              [
                                                M.SubPointer.get_struct_record_field (|
                                                  M.read (| verifier |),
                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "stack"
                                                |)
                                              ]
                                            |)
                                          |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Ok",
                                                    0
                                                  |) in
                                                let x := M.copy (| γ0_0 |) in
                                                x));
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Err",
                                                    0
                                                  |) in
                                                let e := M.copy (| γ0_0 |) in
                                                let~ err :=
                                                  M.alloc (|
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path
                                                          "move_binary_format::errors::PartialVMError",
                                                        "with_message",
                                                        []
                                                      |),
                                                      [
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_binary_format::errors::PartialVMError",
                                                            "new",
                                                            []
                                                          |),
                                                          [
                                                            Value.StructTuple
                                                              "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                              []
                                                          ]
                                                        |);
                                                        M.call_closure (|
                                                          M.get_function (|
                                                            "core::hint::must_use",
                                                            [ Ty.path "alloc::string::String" ]
                                                          |),
                                                          [
                                                            M.read (|
                                                              let~ res :=
                                                                M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_function (|
                                                                      "alloc::fmt::format",
                                                                      []
                                                                    |),
                                                                    [
                                                                      M.call_closure (|
                                                                        M.get_associated_function (|
                                                                          Ty.path
                                                                            "core::fmt::Arguments",
                                                                          "new_v1_formatted",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.read (|
                                                                                  Value.String
                                                                                    "crates/move-bytecode-verifier/src/type_safety.rs:722 "
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Argument",
                                                                                    "new_display",
                                                                                    [
                                                                                      Ty.path
                                                                                        "move_abstract_stack::AbsStackError"
                                                                                    ]
                                                                                  |),
                                                                                  [ e ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Placeholder",
                                                                                    "new",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    Value.Integer
                                                                                      IntegerKind.Usize
                                                                                      0;
                                                                                    Value.UnicodeChar
                                                                                      32;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Alignment::Unknown"
                                                                                      [];
                                                                                    Value.Integer
                                                                                      IntegerKind.U32
                                                                                      4;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      [];
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      []
                                                                                  ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::UnsafeArg",
                                                                              "new",
                                                                              []
                                                                            |),
                                                                            []
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |) in
                                                              res
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) in
                                                M.match_operator (|
                                                  M.alloc (| Value.Tuple [] |),
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let γ :=
                                                          M.use (M.alloc (| Value.Bool true |)) in
                                                        let _ :=
                                                          M.is_constant_or_break_match (|
                                                            M.read (| γ |),
                                                            Value.Bool true
                                                          |) in
                                                        M.alloc (|
                                                          M.never_to_any (|
                                                            M.call_closure (|
                                                              M.get_function (|
                                                                "core::panicking::panic_fmt",
                                                                []
                                                              |),
                                                              [
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.path "core::fmt::Arguments",
                                                                    "new_v1",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.read (|
                                                                            Value.String ""
                                                                          |)
                                                                        ]
                                                                    |);
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::Argument",
                                                                              "new_debug",
                                                                              [
                                                                                Ty.path
                                                                                  "move_binary_format::errors::PartialVMError"
                                                                              ]
                                                                            |),
                                                                            [ err ]
                                                                          |)
                                                                        ]
                                                                    |)
                                                                  ]
                                                                |)
                                                              ]
                                                            |)
                                                          |)
                                                        |)));
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (M.alloc (|
                                                          M.never_to_any (|
                                                            M.read (|
                                                              M.return_ (|
                                                                Value.StructTuple
                                                                  "core::result::Result::Err"
                                                                  [ M.read (| err |) ]
                                                              |)
                                                            |)
                                                          |)
                                                        |)))
                                                  ]
                                                |)))
                                          ]
                                        |)
                                      |) in
                                    let~ operand2 :=
                                      M.copy (|
                                        M.match_operator (|
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.apply
                                                  (Ty.path "move_abstract_stack::AbstractStack")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_binary_format::file_format::SignatureToken"
                                                  ],
                                                "pop",
                                                []
                                              |),
                                              [
                                                M.SubPointer.get_struct_record_field (|
                                                  M.read (| verifier |),
                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "stack"
                                                |)
                                              ]
                                            |)
                                          |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Ok",
                                                    0
                                                  |) in
                                                let x := M.copy (| γ0_0 |) in
                                                x));
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Err",
                                                    0
                                                  |) in
                                                let e := M.copy (| γ0_0 |) in
                                                let~ err :=
                                                  M.alloc (|
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path
                                                          "move_binary_format::errors::PartialVMError",
                                                        "with_message",
                                                        []
                                                      |),
                                                      [
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_binary_format::errors::PartialVMError",
                                                            "new",
                                                            []
                                                          |),
                                                          [
                                                            Value.StructTuple
                                                              "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                              []
                                                          ]
                                                        |);
                                                        M.call_closure (|
                                                          M.get_function (|
                                                            "core::hint::must_use",
                                                            [ Ty.path "alloc::string::String" ]
                                                          |),
                                                          [
                                                            M.read (|
                                                              let~ res :=
                                                                M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_function (|
                                                                      "alloc::fmt::format",
                                                                      []
                                                                    |),
                                                                    [
                                                                      M.call_closure (|
                                                                        M.get_associated_function (|
                                                                          Ty.path
                                                                            "core::fmt::Arguments",
                                                                          "new_v1_formatted",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.read (|
                                                                                  Value.String
                                                                                    "crates/move-bytecode-verifier/src/type_safety.rs:723 "
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Argument",
                                                                                    "new_display",
                                                                                    [
                                                                                      Ty.path
                                                                                        "move_abstract_stack::AbsStackError"
                                                                                    ]
                                                                                  |),
                                                                                  [ e ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Placeholder",
                                                                                    "new",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    Value.Integer
                                                                                      IntegerKind.Usize
                                                                                      0;
                                                                                    Value.UnicodeChar
                                                                                      32;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Alignment::Unknown"
                                                                                      [];
                                                                                    Value.Integer
                                                                                      IntegerKind.U32
                                                                                      4;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      [];
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      []
                                                                                  ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::UnsafeArg",
                                                                              "new",
                                                                              []
                                                                            |),
                                                                            []
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |) in
                                                              res
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) in
                                                M.match_operator (|
                                                  M.alloc (| Value.Tuple [] |),
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let γ :=
                                                          M.use (M.alloc (| Value.Bool true |)) in
                                                        let _ :=
                                                          M.is_constant_or_break_match (|
                                                            M.read (| γ |),
                                                            Value.Bool true
                                                          |) in
                                                        M.alloc (|
                                                          M.never_to_any (|
                                                            M.call_closure (|
                                                              M.get_function (|
                                                                "core::panicking::panic_fmt",
                                                                []
                                                              |),
                                                              [
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.path "core::fmt::Arguments",
                                                                    "new_v1",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.read (|
                                                                            Value.String ""
                                                                          |)
                                                                        ]
                                                                    |);
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::Argument",
                                                                              "new_debug",
                                                                              [
                                                                                Ty.path
                                                                                  "move_binary_format::errors::PartialVMError"
                                                                              ]
                                                                            |),
                                                                            [ err ]
                                                                          |)
                                                                        ]
                                                                    |)
                                                                  ]
                                                                |)
                                                              ]
                                                            |)
                                                          |)
                                                        |)));
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (M.alloc (|
                                                          M.never_to_any (|
                                                            M.read (|
                                                              M.return_ (|
                                                                Value.StructTuple
                                                                  "core::result::Result::Err"
                                                                  [ M.read (| err |) ]
                                                              |)
                                                            |)
                                                          |)
                                                        |)))
                                                  ]
                                                |)))
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  LogicalOp.and (|
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path
                                                          "move_binary_format::file_format::SignatureToken",
                                                        "is_integer",
                                                        []
                                                      |),
                                                      [ operand1 ]
                                                    |),
                                                    ltac:(M.monadic
                                                      (M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.path
                                                            "move_binary_format::file_format::SignatureToken",
                                                          [
                                                            Ty.path
                                                              "move_binary_format::file_format::SignatureToken"
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [ operand1; operand2 ]
                                                      |)))
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) 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_associated_function (|
                                                          Ty.path
                                                            "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                          "push",
                                                          [ impl_Meter__plus___Sized ]
                                                        |),
                                                        [
                                                          M.read (| verifier |);
                                                          M.read (| meter |);
                                                          M.read (| operand1 |)
                                                        ]
                                                      |)
                                                    ]
                                                  |)
                                                |),
                                                [
                                                  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.alloc (| Value.Tuple [] |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                            "error",
                                                            []
                                                          |),
                                                          [
                                                            M.read (| verifier |);
                                                            Value.StructTuple
                                                              "move_core_types::vm_status::StatusCode::INTEGER_OP_TYPE_MISMATCH_ERROR"
                                                              [];
                                                            M.read (| offset |)
                                                          ]
                                                        |)
                                                      ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                                | _ => M.impossible "wrong number of arguments"
                                end))
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (M.find_or_pattern (|
                          γ,
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::Shl"
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::Shr"
                                  |) in
                                Value.Tuple []))
                          ],
                          M.closure
                            (fun γ =>
                              ltac:(M.monadic
                                match γ with
                                | [] =>
                                  ltac:(M.monadic
                                    (let~ operand1 :=
                                      M.copy (|
                                        M.match_operator (|
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.apply
                                                  (Ty.path "move_abstract_stack::AbstractStack")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_binary_format::file_format::SignatureToken"
                                                  ],
                                                "pop",
                                                []
                                              |),
                                              [
                                                M.SubPointer.get_struct_record_field (|
                                                  M.read (| verifier |),
                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "stack"
                                                |)
                                              ]
                                            |)
                                          |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Ok",
                                                    0
                                                  |) in
                                                let x := M.copy (| γ0_0 |) in
                                                x));
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Err",
                                                    0
                                                  |) in
                                                let e := M.copy (| γ0_0 |) in
                                                let~ err :=
                                                  M.alloc (|
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path
                                                          "move_binary_format::errors::PartialVMError",
                                                        "with_message",
                                                        []
                                                      |),
                                                      [
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_binary_format::errors::PartialVMError",
                                                            "new",
                                                            []
                                                          |),
                                                          [
                                                            Value.StructTuple
                                                              "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                              []
                                                          ]
                                                        |);
                                                        M.call_closure (|
                                                          M.get_function (|
                                                            "core::hint::must_use",
                                                            [ Ty.path "alloc::string::String" ]
                                                          |),
                                                          [
                                                            M.read (|
                                                              let~ res :=
                                                                M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_function (|
                                                                      "alloc::fmt::format",
                                                                      []
                                                                    |),
                                                                    [
                                                                      M.call_closure (|
                                                                        M.get_associated_function (|
                                                                          Ty.path
                                                                            "core::fmt::Arguments",
                                                                          "new_v1_formatted",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.read (|
                                                                                  Value.String
                                                                                    "crates/move-bytecode-verifier/src/type_safety.rs:732 "
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Argument",
                                                                                    "new_display",
                                                                                    [
                                                                                      Ty.path
                                                                                        "move_abstract_stack::AbsStackError"
                                                                                    ]
                                                                                  |),
                                                                                  [ e ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Placeholder",
                                                                                    "new",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    Value.Integer
                                                                                      IntegerKind.Usize
                                                                                      0;
                                                                                    Value.UnicodeChar
                                                                                      32;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Alignment::Unknown"
                                                                                      [];
                                                                                    Value.Integer
                                                                                      IntegerKind.U32
                                                                                      4;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      [];
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      []
                                                                                  ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::UnsafeArg",
                                                                              "new",
                                                                              []
                                                                            |),
                                                                            []
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |) in
                                                              res
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) in
                                                M.match_operator (|
                                                  M.alloc (| Value.Tuple [] |),
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let γ :=
                                                          M.use (M.alloc (| Value.Bool true |)) in
                                                        let _ :=
                                                          M.is_constant_or_break_match (|
                                                            M.read (| γ |),
                                                            Value.Bool true
                                                          |) in
                                                        M.alloc (|
                                                          M.never_to_any (|
                                                            M.call_closure (|
                                                              M.get_function (|
                                                                "core::panicking::panic_fmt",
                                                                []
                                                              |),
                                                              [
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.path "core::fmt::Arguments",
                                                                    "new_v1",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.read (|
                                                                            Value.String ""
                                                                          |)
                                                                        ]
                                                                    |);
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::Argument",
                                                                              "new_debug",
                                                                              [
                                                                                Ty.path
                                                                                  "move_binary_format::errors::PartialVMError"
                                                                              ]
                                                                            |),
                                                                            [ err ]
                                                                          |)
                                                                        ]
                                                                    |)
                                                                  ]
                                                                |)
                                                              ]
                                                            |)
                                                          |)
                                                        |)));
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (M.alloc (|
                                                          M.never_to_any (|
                                                            M.read (|
                                                              M.return_ (|
                                                                Value.StructTuple
                                                                  "core::result::Result::Err"
                                                                  [ M.read (| err |) ]
                                                              |)
                                                            |)
                                                          |)
                                                        |)))
                                                  ]
                                                |)))
                                          ]
                                        |)
                                      |) in
                                    let~ operand2 :=
                                      M.copy (|
                                        M.match_operator (|
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.apply
                                                  (Ty.path "move_abstract_stack::AbstractStack")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_binary_format::file_format::SignatureToken"
                                                  ],
                                                "pop",
                                                []
                                              |),
                                              [
                                                M.SubPointer.get_struct_record_field (|
                                                  M.read (| verifier |),
                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "stack"
                                                |)
                                              ]
                                            |)
                                          |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Ok",
                                                    0
                                                  |) in
                                                let x := M.copy (| γ0_0 |) in
                                                x));
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Err",
                                                    0
                                                  |) in
                                                let e := M.copy (| γ0_0 |) in
                                                let~ err :=
                                                  M.alloc (|
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path
                                                          "move_binary_format::errors::PartialVMError",
                                                        "with_message",
                                                        []
                                                      |),
                                                      [
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_binary_format::errors::PartialVMError",
                                                            "new",
                                                            []
                                                          |),
                                                          [
                                                            Value.StructTuple
                                                              "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                              []
                                                          ]
                                                        |);
                                                        M.call_closure (|
                                                          M.get_function (|
                                                            "core::hint::must_use",
                                                            [ Ty.path "alloc::string::String" ]
                                                          |),
                                                          [
                                                            M.read (|
                                                              let~ res :=
                                                                M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_function (|
                                                                      "alloc::fmt::format",
                                                                      []
                                                                    |),
                                                                    [
                                                                      M.call_closure (|
                                                                        M.get_associated_function (|
                                                                          Ty.path
                                                                            "core::fmt::Arguments",
                                                                          "new_v1_formatted",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.read (|
                                                                                  Value.String
                                                                                    "crates/move-bytecode-verifier/src/type_safety.rs:733 "
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Argument",
                                                                                    "new_display",
                                                                                    [
                                                                                      Ty.path
                                                                                        "move_abstract_stack::AbsStackError"
                                                                                    ]
                                                                                  |),
                                                                                  [ e ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Placeholder",
                                                                                    "new",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    Value.Integer
                                                                                      IntegerKind.Usize
                                                                                      0;
                                                                                    Value.UnicodeChar
                                                                                      32;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Alignment::Unknown"
                                                                                      [];
                                                                                    Value.Integer
                                                                                      IntegerKind.U32
                                                                                      4;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      [];
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      []
                                                                                  ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::UnsafeArg",
                                                                              "new",
                                                                              []
                                                                            |),
                                                                            []
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |) in
                                                              res
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) in
                                                M.match_operator (|
                                                  M.alloc (| Value.Tuple [] |),
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let γ :=
                                                          M.use (M.alloc (| Value.Bool true |)) in
                                                        let _ :=
                                                          M.is_constant_or_break_match (|
                                                            M.read (| γ |),
                                                            Value.Bool true
                                                          |) in
                                                        M.alloc (|
                                                          M.never_to_any (|
                                                            M.call_closure (|
                                                              M.get_function (|
                                                                "core::panicking::panic_fmt",
                                                                []
                                                              |),
                                                              [
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.path "core::fmt::Arguments",
                                                                    "new_v1",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.read (|
                                                                            Value.String ""
                                                                          |)
                                                                        ]
                                                                    |);
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::Argument",
                                                                              "new_debug",
                                                                              [
                                                                                Ty.path
                                                                                  "move_binary_format::errors::PartialVMError"
                                                                              ]
                                                                            |),
                                                                            [ err ]
                                                                          |)
                                                                        ]
                                                                    |)
                                                                  ]
                                                                |)
                                                              ]
                                                            |)
                                                          |)
                                                        |)));
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (M.alloc (|
                                                          M.never_to_any (|
                                                            M.read (|
                                                              M.return_ (|
                                                                Value.StructTuple
                                                                  "core::result::Result::Err"
                                                                  [ M.read (| err |) ]
                                                              |)
                                                            |)
                                                          |)
                                                        |)))
                                                  ]
                                                |)))
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  LogicalOp.and (|
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path
                                                          "move_binary_format::file_format::SignatureToken",
                                                        "is_integer",
                                                        []
                                                      |),
                                                      [ operand2 ]
                                                    |),
                                                    ltac:(M.monadic
                                                      (M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.path
                                                            "move_binary_format::file_format::SignatureToken",
                                                          [
                                                            Ty.path
                                                              "move_binary_format::file_format::SignatureToken"
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          operand1;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "move_binary_format::file_format::SignatureToken::U8"
                                                              []
                                                          |)
                                                        ]
                                                      |)))
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) 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_associated_function (|
                                                          Ty.path
                                                            "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                          "push",
                                                          [ impl_Meter__plus___Sized ]
                                                        |),
                                                        [
                                                          M.read (| verifier |);
                                                          M.read (| meter |);
                                                          M.read (| operand2 |)
                                                        ]
                                                      |)
                                                    ]
                                                  |)
                                                |),
                                                [
                                                  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.alloc (| Value.Tuple [] |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                            "error",
                                                            []
                                                          |),
                                                          [
                                                            M.read (| verifier |);
                                                            Value.StructTuple
                                                              "move_core_types::vm_status::StatusCode::INTEGER_OP_TYPE_MISMATCH_ERROR"
                                                              [];
                                                            M.read (| offset |)
                                                          ]
                                                        |)
                                                      ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                                | _ => M.impossible "wrong number of arguments"
                                end))
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (M.find_or_pattern (|
                          γ,
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::Or"
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::And"
                                  |) in
                                Value.Tuple []))
                          ],
                          M.closure
                            (fun γ =>
                              ltac:(M.monadic
                                match γ with
                                | [] =>
                                  ltac:(M.monadic
                                    (let~ operand1 :=
                                      M.copy (|
                                        M.match_operator (|
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.apply
                                                  (Ty.path "move_abstract_stack::AbstractStack")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_binary_format::file_format::SignatureToken"
                                                  ],
                                                "pop",
                                                []
                                              |),
                                              [
                                                M.SubPointer.get_struct_record_field (|
                                                  M.read (| verifier |),
                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "stack"
                                                |)
                                              ]
                                            |)
                                          |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Ok",
                                                    0
                                                  |) in
                                                let x := M.copy (| γ0_0 |) in
                                                x));
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Err",
                                                    0
                                                  |) in
                                                let e := M.copy (| γ0_0 |) in
                                                let~ err :=
                                                  M.alloc (|
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path
                                                          "move_binary_format::errors::PartialVMError",
                                                        "with_message",
                                                        []
                                                      |),
                                                      [
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_binary_format::errors::PartialVMError",
                                                            "new",
                                                            []
                                                          |),
                                                          [
                                                            Value.StructTuple
                                                              "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                              []
                                                          ]
                                                        |);
                                                        M.call_closure (|
                                                          M.get_function (|
                                                            "core::hint::must_use",
                                                            [ Ty.path "alloc::string::String" ]
                                                          |),
                                                          [
                                                            M.read (|
                                                              let~ res :=
                                                                M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_function (|
                                                                      "alloc::fmt::format",
                                                                      []
                                                                    |),
                                                                    [
                                                                      M.call_closure (|
                                                                        M.get_associated_function (|
                                                                          Ty.path
                                                                            "core::fmt::Arguments",
                                                                          "new_v1_formatted",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.read (|
                                                                                  Value.String
                                                                                    "crates/move-bytecode-verifier/src/type_safety.rs:742 "
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Argument",
                                                                                    "new_display",
                                                                                    [
                                                                                      Ty.path
                                                                                        "move_abstract_stack::AbsStackError"
                                                                                    ]
                                                                                  |),
                                                                                  [ e ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Placeholder",
                                                                                    "new",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    Value.Integer
                                                                                      IntegerKind.Usize
                                                                                      0;
                                                                                    Value.UnicodeChar
                                                                                      32;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Alignment::Unknown"
                                                                                      [];
                                                                                    Value.Integer
                                                                                      IntegerKind.U32
                                                                                      4;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      [];
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      []
                                                                                  ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::UnsafeArg",
                                                                              "new",
                                                                              []
                                                                            |),
                                                                            []
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |) in
                                                              res
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) in
                                                M.match_operator (|
                                                  M.alloc (| Value.Tuple [] |),
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let γ :=
                                                          M.use (M.alloc (| Value.Bool true |)) in
                                                        let _ :=
                                                          M.is_constant_or_break_match (|
                                                            M.read (| γ |),
                                                            Value.Bool true
                                                          |) in
                                                        M.alloc (|
                                                          M.never_to_any (|
                                                            M.call_closure (|
                                                              M.get_function (|
                                                                "core::panicking::panic_fmt",
                                                                []
                                                              |),
                                                              [
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.path "core::fmt::Arguments",
                                                                    "new_v1",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.read (|
                                                                            Value.String ""
                                                                          |)
                                                                        ]
                                                                    |);
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::Argument",
                                                                              "new_debug",
                                                                              [
                                                                                Ty.path
                                                                                  "move_binary_format::errors::PartialVMError"
                                                                              ]
                                                                            |),
                                                                            [ err ]
                                                                          |)
                                                                        ]
                                                                    |)
                                                                  ]
                                                                |)
                                                              ]
                                                            |)
                                                          |)
                                                        |)));
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (M.alloc (|
                                                          M.never_to_any (|
                                                            M.read (|
                                                              M.return_ (|
                                                                Value.StructTuple
                                                                  "core::result::Result::Err"
                                                                  [ M.read (| err |) ]
                                                              |)
                                                            |)
                                                          |)
                                                        |)))
                                                  ]
                                                |)))
                                          ]
                                        |)
                                      |) in
                                    let~ operand2 :=
                                      M.copy (|
                                        M.match_operator (|
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.apply
                                                  (Ty.path "move_abstract_stack::AbstractStack")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_binary_format::file_format::SignatureToken"
                                                  ],
                                                "pop",
                                                []
                                              |),
                                              [
                                                M.SubPointer.get_struct_record_field (|
                                                  M.read (| verifier |),
                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "stack"
                                                |)
                                              ]
                                            |)
                                          |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Ok",
                                                    0
                                                  |) in
                                                let x := M.copy (| γ0_0 |) in
                                                x));
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Err",
                                                    0
                                                  |) in
                                                let e := M.copy (| γ0_0 |) in
                                                let~ err :=
                                                  M.alloc (|
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path
                                                          "move_binary_format::errors::PartialVMError",
                                                        "with_message",
                                                        []
                                                      |),
                                                      [
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_binary_format::errors::PartialVMError",
                                                            "new",
                                                            []
                                                          |),
                                                          [
                                                            Value.StructTuple
                                                              "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                              []
                                                          ]
                                                        |);
                                                        M.call_closure (|
                                                          M.get_function (|
                                                            "core::hint::must_use",
                                                            [ Ty.path "alloc::string::String" ]
                                                          |),
                                                          [
                                                            M.read (|
                                                              let~ res :=
                                                                M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_function (|
                                                                      "alloc::fmt::format",
                                                                      []
                                                                    |),
                                                                    [
                                                                      M.call_closure (|
                                                                        M.get_associated_function (|
                                                                          Ty.path
                                                                            "core::fmt::Arguments",
                                                                          "new_v1_formatted",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.read (|
                                                                                  Value.String
                                                                                    "crates/move-bytecode-verifier/src/type_safety.rs:743 "
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Argument",
                                                                                    "new_display",
                                                                                    [
                                                                                      Ty.path
                                                                                        "move_abstract_stack::AbsStackError"
                                                                                    ]
                                                                                  |),
                                                                                  [ e ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Placeholder",
                                                                                    "new",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    Value.Integer
                                                                                      IntegerKind.Usize
                                                                                      0;
                                                                                    Value.UnicodeChar
                                                                                      32;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Alignment::Unknown"
                                                                                      [];
                                                                                    Value.Integer
                                                                                      IntegerKind.U32
                                                                                      4;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      [];
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      []
                                                                                  ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::UnsafeArg",
                                                                              "new",
                                                                              []
                                                                            |),
                                                                            []
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |) in
                                                              res
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) in
                                                M.match_operator (|
                                                  M.alloc (| Value.Tuple [] |),
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let γ :=
                                                          M.use (M.alloc (| Value.Bool true |)) in
                                                        let _ :=
                                                          M.is_constant_or_break_match (|
                                                            M.read (| γ |),
                                                            Value.Bool true
                                                          |) in
                                                        M.alloc (|
                                                          M.never_to_any (|
                                                            M.call_closure (|
                                                              M.get_function (|
                                                                "core::panicking::panic_fmt",
                                                                []
                                                              |),
                                                              [
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.path "core::fmt::Arguments",
                                                                    "new_v1",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.read (|
                                                                            Value.String ""
                                                                          |)
                                                                        ]
                                                                    |);
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::Argument",
                                                                              "new_debug",
                                                                              [
                                                                                Ty.path
                                                                                  "move_binary_format::errors::PartialVMError"
                                                                              ]
                                                                            |),
                                                                            [ err ]
                                                                          |)
                                                                        ]
                                                                    |)
                                                                  ]
                                                                |)
                                                              ]
                                                            |)
                                                          |)
                                                        |)));
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (M.alloc (|
                                                          M.never_to_any (|
                                                            M.read (|
                                                              M.return_ (|
                                                                Value.StructTuple
                                                                  "core::result::Result::Err"
                                                                  [ M.read (| err |) ]
                                                              |)
                                                            |)
                                                          |)
                                                        |)))
                                                  ]
                                                |)))
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  LogicalOp.and (|
                                                    M.call_closure (|
                                                      M.get_trait_method (|
                                                        "core::cmp::PartialEq",
                                                        Ty.path
                                                          "move_binary_format::file_format::SignatureToken",
                                                        [
                                                          Ty.path
                                                            "move_binary_format::file_format::SignatureToken"
                                                        ],
                                                        "eq",
                                                        []
                                                      |),
                                                      [
                                                        operand1;
                                                        M.alloc (|
                                                          Value.StructTuple
                                                            "move_binary_format::file_format::SignatureToken::Bool"
                                                            []
                                                        |)
                                                      ]
                                                    |),
                                                    ltac:(M.monadic
                                                      (M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.path
                                                            "move_binary_format::file_format::SignatureToken",
                                                          [
                                                            Ty.path
                                                              "move_binary_format::file_format::SignatureToken"
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          operand2;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "move_binary_format::file_format::SignatureToken::Bool"
                                                              []
                                                          |)
                                                        ]
                                                      |)))
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) 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_associated_function (|
                                                          Ty.path
                                                            "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                          "push",
                                                          [ impl_Meter__plus___Sized ]
                                                        |),
                                                        [
                                                          M.read (| verifier |);
                                                          M.read (| meter |);
                                                          Value.StructTuple
                                                            "move_binary_format::file_format::SignatureToken::Bool"
                                                            []
                                                        ]
                                                      |)
                                                    ]
                                                  |)
                                                |),
                                                [
                                                  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.alloc (| Value.Tuple [] |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                            "error",
                                                            []
                                                          |),
                                                          [
                                                            M.read (| verifier |);
                                                            Value.StructTuple
                                                              "move_core_types::vm_status::StatusCode::BOOLEAN_OP_TYPE_MISMATCH_ERROR"
                                                              [];
                                                            M.read (| offset |)
                                                          ]
                                                        |)
                                                      ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                                | _ => M.impossible "wrong number of arguments"
                                end))
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (|
                            γ,
                            "move_binary_format::file_format::Bytecode::Not"
                          |) in
                        let~ operand :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:752 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        M.match_operator (|
                          M.alloc (| Value.Tuple [] |),
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (let γ :=
                                  M.use
                                    (M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.path "move_binary_format::file_format::SignatureToken",
                                          [
                                            Ty.path
                                              "move_binary_format::file_format::SignatureToken"
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          operand;
                                          M.alloc (|
                                            Value.StructTuple
                                              "move_binary_format::file_format::SignatureToken::Bool"
                                              []
                                          |)
                                        ]
                                      |)
                                    |)) in
                                let _ :=
                                  M.is_constant_or_break_match (|
                                    M.read (| γ |),
                                    Value.Bool true
                                  |) 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_associated_function (|
                                              Ty.path
                                                "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                              "push",
                                              [ impl_Meter__plus___Sized ]
                                            |),
                                            [
                                              M.read (| verifier |);
                                              M.read (| meter |);
                                              Value.StructTuple
                                                "move_binary_format::file_format::SignatureToken::Bool"
                                                []
                                            ]
                                          |)
                                        ]
                                      |)
                                    |),
                                    [
                                      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.alloc (| Value.Tuple [] |)));
                            fun γ =>
                              ltac:(M.monadic
                                (M.alloc (|
                                  M.never_to_any (|
                                    M.read (|
                                      M.return_ (|
                                        Value.StructTuple
                                          "core::result::Result::Err"
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                "error",
                                                []
                                              |),
                                              [
                                                M.read (| verifier |);
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::BOOLEAN_OP_TYPE_MISMATCH_ERROR"
                                                  [];
                                                M.read (| offset |)
                                              ]
                                            |)
                                          ]
                                      |)
                                    |)
                                  |)
                                |)))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (M.find_or_pattern (|
                          γ,
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::Eq"
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::Neq"
                                  |) in
                                Value.Tuple []))
                          ],
                          M.closure
                            (fun γ =>
                              ltac:(M.monadic
                                match γ with
                                | [] =>
                                  ltac:(M.monadic
                                    (let~ operand1 :=
                                      M.copy (|
                                        M.match_operator (|
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.apply
                                                  (Ty.path "move_abstract_stack::AbstractStack")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_binary_format::file_format::SignatureToken"
                                                  ],
                                                "pop",
                                                []
                                              |),
                                              [
                                                M.SubPointer.get_struct_record_field (|
                                                  M.read (| verifier |),
                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "stack"
                                                |)
                                              ]
                                            |)
                                          |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Ok",
                                                    0
                                                  |) in
                                                let x := M.copy (| γ0_0 |) in
                                                x));
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Err",
                                                    0
                                                  |) in
                                                let e := M.copy (| γ0_0 |) in
                                                let~ err :=
                                                  M.alloc (|
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path
                                                          "move_binary_format::errors::PartialVMError",
                                                        "with_message",
                                                        []
                                                      |),
                                                      [
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_binary_format::errors::PartialVMError",
                                                            "new",
                                                            []
                                                          |),
                                                          [
                                                            Value.StructTuple
                                                              "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                              []
                                                          ]
                                                        |);
                                                        M.call_closure (|
                                                          M.get_function (|
                                                            "core::hint::must_use",
                                                            [ Ty.path "alloc::string::String" ]
                                                          |),
                                                          [
                                                            M.read (|
                                                              let~ res :=
                                                                M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_function (|
                                                                      "alloc::fmt::format",
                                                                      []
                                                                    |),
                                                                    [
                                                                      M.call_closure (|
                                                                        M.get_associated_function (|
                                                                          Ty.path
                                                                            "core::fmt::Arguments",
                                                                          "new_v1_formatted",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.read (|
                                                                                  Value.String
                                                                                    "crates/move-bytecode-verifier/src/type_safety.rs:761 "
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Argument",
                                                                                    "new_display",
                                                                                    [
                                                                                      Ty.path
                                                                                        "move_abstract_stack::AbsStackError"
                                                                                    ]
                                                                                  |),
                                                                                  [ e ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Placeholder",
                                                                                    "new",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    Value.Integer
                                                                                      IntegerKind.Usize
                                                                                      0;
                                                                                    Value.UnicodeChar
                                                                                      32;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Alignment::Unknown"
                                                                                      [];
                                                                                    Value.Integer
                                                                                      IntegerKind.U32
                                                                                      4;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      [];
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      []
                                                                                  ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::UnsafeArg",
                                                                              "new",
                                                                              []
                                                                            |),
                                                                            []
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |) in
                                                              res
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) in
                                                M.match_operator (|
                                                  M.alloc (| Value.Tuple [] |),
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let γ :=
                                                          M.use (M.alloc (| Value.Bool true |)) in
                                                        let _ :=
                                                          M.is_constant_or_break_match (|
                                                            M.read (| γ |),
                                                            Value.Bool true
                                                          |) in
                                                        M.alloc (|
                                                          M.never_to_any (|
                                                            M.call_closure (|
                                                              M.get_function (|
                                                                "core::panicking::panic_fmt",
                                                                []
                                                              |),
                                                              [
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.path "core::fmt::Arguments",
                                                                    "new_v1",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.read (|
                                                                            Value.String ""
                                                                          |)
                                                                        ]
                                                                    |);
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::Argument",
                                                                              "new_debug",
                                                                              [
                                                                                Ty.path
                                                                                  "move_binary_format::errors::PartialVMError"
                                                                              ]
                                                                            |),
                                                                            [ err ]
                                                                          |)
                                                                        ]
                                                                    |)
                                                                  ]
                                                                |)
                                                              ]
                                                            |)
                                                          |)
                                                        |)));
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (M.alloc (|
                                                          M.never_to_any (|
                                                            M.read (|
                                                              M.return_ (|
                                                                Value.StructTuple
                                                                  "core::result::Result::Err"
                                                                  [ M.read (| err |) ]
                                                              |)
                                                            |)
                                                          |)
                                                        |)))
                                                  ]
                                                |)))
                                          ]
                                        |)
                                      |) in
                                    let~ operand2 :=
                                      M.copy (|
                                        M.match_operator (|
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.apply
                                                  (Ty.path "move_abstract_stack::AbstractStack")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_binary_format::file_format::SignatureToken"
                                                  ],
                                                "pop",
                                                []
                                              |),
                                              [
                                                M.SubPointer.get_struct_record_field (|
                                                  M.read (| verifier |),
                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "stack"
                                                |)
                                              ]
                                            |)
                                          |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Ok",
                                                    0
                                                  |) in
                                                let x := M.copy (| γ0_0 |) in
                                                x));
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Err",
                                                    0
                                                  |) in
                                                let e := M.copy (| γ0_0 |) in
                                                let~ err :=
                                                  M.alloc (|
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path
                                                          "move_binary_format::errors::PartialVMError",
                                                        "with_message",
                                                        []
                                                      |),
                                                      [
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_binary_format::errors::PartialVMError",
                                                            "new",
                                                            []
                                                          |),
                                                          [
                                                            Value.StructTuple
                                                              "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                              []
                                                          ]
                                                        |);
                                                        M.call_closure (|
                                                          M.get_function (|
                                                            "core::hint::must_use",
                                                            [ Ty.path "alloc::string::String" ]
                                                          |),
                                                          [
                                                            M.read (|
                                                              let~ res :=
                                                                M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_function (|
                                                                      "alloc::fmt::format",
                                                                      []
                                                                    |),
                                                                    [
                                                                      M.call_closure (|
                                                                        M.get_associated_function (|
                                                                          Ty.path
                                                                            "core::fmt::Arguments",
                                                                          "new_v1_formatted",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.read (|
                                                                                  Value.String
                                                                                    "crates/move-bytecode-verifier/src/type_safety.rs:762 "
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Argument",
                                                                                    "new_display",
                                                                                    [
                                                                                      Ty.path
                                                                                        "move_abstract_stack::AbsStackError"
                                                                                    ]
                                                                                  |),
                                                                                  [ e ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Placeholder",
                                                                                    "new",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    Value.Integer
                                                                                      IntegerKind.Usize
                                                                                      0;
                                                                                    Value.UnicodeChar
                                                                                      32;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Alignment::Unknown"
                                                                                      [];
                                                                                    Value.Integer
                                                                                      IntegerKind.U32
                                                                                      4;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      [];
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      []
                                                                                  ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::UnsafeArg",
                                                                              "new",
                                                                              []
                                                                            |),
                                                                            []
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |) in
                                                              res
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) in
                                                M.match_operator (|
                                                  M.alloc (| Value.Tuple [] |),
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let γ :=
                                                          M.use (M.alloc (| Value.Bool true |)) in
                                                        let _ :=
                                                          M.is_constant_or_break_match (|
                                                            M.read (| γ |),
                                                            Value.Bool true
                                                          |) in
                                                        M.alloc (|
                                                          M.never_to_any (|
                                                            M.call_closure (|
                                                              M.get_function (|
                                                                "core::panicking::panic_fmt",
                                                                []
                                                              |),
                                                              [
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.path "core::fmt::Arguments",
                                                                    "new_v1",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.read (|
                                                                            Value.String ""
                                                                          |)
                                                                        ]
                                                                    |);
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::Argument",
                                                                              "new_debug",
                                                                              [
                                                                                Ty.path
                                                                                  "move_binary_format::errors::PartialVMError"
                                                                              ]
                                                                            |),
                                                                            [ err ]
                                                                          |)
                                                                        ]
                                                                    |)
                                                                  ]
                                                                |)
                                                              ]
                                                            |)
                                                          |)
                                                        |)));
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (M.alloc (|
                                                          M.never_to_any (|
                                                            M.read (|
                                                              M.return_ (|
                                                                Value.StructTuple
                                                                  "core::result::Result::Err"
                                                                  [ M.read (| err |) ]
                                                              |)
                                                            |)
                                                          |)
                                                        |)))
                                                  ]
                                                |)))
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  LogicalOp.and (|
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path
                                                          "move_binary_format::file_format::AbilitySet",
                                                        "has_drop",
                                                        []
                                                      |),
                                                      [
                                                        M.read (|
                                                          M.match_operator (|
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::ops::try_trait::Try",
                                                                  Ty.apply
                                                                    (Ty.path "core::result::Result")
                                                                    []
                                                                    [
                                                                      Ty.path
                                                                        "move_binary_format::file_format::AbilitySet";
                                                                      Ty.path
                                                                        "move_binary_format::errors::PartialVMError"
                                                                    ],
                                                                  [],
                                                                  "branch",
                                                                  []
                                                                |),
                                                                [
                                                                  M.call_closure (|
                                                                    M.get_associated_function (|
                                                                      Ty.path
                                                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                                      "abilities",
                                                                      []
                                                                    |),
                                                                    [
                                                                      M.read (| verifier |);
                                                                      operand1
                                                                    ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |),
                                                            [
                                                              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))
                                                            ]
                                                          |)
                                                        |)
                                                      ]
                                                    |),
                                                    ltac:(M.monadic
                                                      (M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.path
                                                            "move_binary_format::file_format::SignatureToken",
                                                          [
                                                            Ty.path
                                                              "move_binary_format::file_format::SignatureToken"
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [ operand1; operand2 ]
                                                      |)))
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) 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_associated_function (|
                                                          Ty.path
                                                            "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                          "push",
                                                          [ impl_Meter__plus___Sized ]
                                                        |),
                                                        [
                                                          M.read (| verifier |);
                                                          M.read (| meter |);
                                                          Value.StructTuple
                                                            "move_binary_format::file_format::SignatureToken::Bool"
                                                            []
                                                        ]
                                                      |)
                                                    ]
                                                  |)
                                                |),
                                                [
                                                  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.alloc (| Value.Tuple [] |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                            "error",
                                                            []
                                                          |),
                                                          [
                                                            M.read (| verifier |);
                                                            Value.StructTuple
                                                              "move_core_types::vm_status::StatusCode::EQUALITY_OP_TYPE_MISMATCH_ERROR"
                                                              [];
                                                            M.read (| offset |)
                                                          ]
                                                        |)
                                                      ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                                | _ => M.impossible "wrong number of arguments"
                                end))
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (M.find_or_pattern (|
                          γ,
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::Lt"
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::Gt"
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::Le"
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::Ge"
                                  |) in
                                Value.Tuple []))
                          ],
                          M.closure
                            (fun γ =>
                              ltac:(M.monadic
                                match γ with
                                | [] =>
                                  ltac:(M.monadic
                                    (let~ operand1 :=
                                      M.copy (|
                                        M.match_operator (|
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.apply
                                                  (Ty.path "move_abstract_stack::AbstractStack")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_binary_format::file_format::SignatureToken"
                                                  ],
                                                "pop",
                                                []
                                              |),
                                              [
                                                M.SubPointer.get_struct_record_field (|
                                                  M.read (| verifier |),
                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "stack"
                                                |)
                                              ]
                                            |)
                                          |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Ok",
                                                    0
                                                  |) in
                                                let x := M.copy (| γ0_0 |) in
                                                x));
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Err",
                                                    0
                                                  |) in
                                                let e := M.copy (| γ0_0 |) in
                                                let~ err :=
                                                  M.alloc (|
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path
                                                          "move_binary_format::errors::PartialVMError",
                                                        "with_message",
                                                        []
                                                      |),
                                                      [
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_binary_format::errors::PartialVMError",
                                                            "new",
                                                            []
                                                          |),
                                                          [
                                                            Value.StructTuple
                                                              "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                              []
                                                          ]
                                                        |);
                                                        M.call_closure (|
                                                          M.get_function (|
                                                            "core::hint::must_use",
                                                            [ Ty.path "alloc::string::String" ]
                                                          |),
                                                          [
                                                            M.read (|
                                                              let~ res :=
                                                                M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_function (|
                                                                      "alloc::fmt::format",
                                                                      []
                                                                    |),
                                                                    [
                                                                      M.call_closure (|
                                                                        M.get_associated_function (|
                                                                          Ty.path
                                                                            "core::fmt::Arguments",
                                                                          "new_v1_formatted",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.read (|
                                                                                  Value.String
                                                                                    "crates/move-bytecode-verifier/src/type_safety.rs:771 "
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Argument",
                                                                                    "new_display",
                                                                                    [
                                                                                      Ty.path
                                                                                        "move_abstract_stack::AbsStackError"
                                                                                    ]
                                                                                  |),
                                                                                  [ e ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Placeholder",
                                                                                    "new",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    Value.Integer
                                                                                      IntegerKind.Usize
                                                                                      0;
                                                                                    Value.UnicodeChar
                                                                                      32;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Alignment::Unknown"
                                                                                      [];
                                                                                    Value.Integer
                                                                                      IntegerKind.U32
                                                                                      4;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      [];
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      []
                                                                                  ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::UnsafeArg",
                                                                              "new",
                                                                              []
                                                                            |),
                                                                            []
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |) in
                                                              res
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) in
                                                M.match_operator (|
                                                  M.alloc (| Value.Tuple [] |),
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let γ :=
                                                          M.use (M.alloc (| Value.Bool true |)) in
                                                        let _ :=
                                                          M.is_constant_or_break_match (|
                                                            M.read (| γ |),
                                                            Value.Bool true
                                                          |) in
                                                        M.alloc (|
                                                          M.never_to_any (|
                                                            M.call_closure (|
                                                              M.get_function (|
                                                                "core::panicking::panic_fmt",
                                                                []
                                                              |),
                                                              [
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.path "core::fmt::Arguments",
                                                                    "new_v1",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.read (|
                                                                            Value.String ""
                                                                          |)
                                                                        ]
                                                                    |);
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::Argument",
                                                                              "new_debug",
                                                                              [
                                                                                Ty.path
                                                                                  "move_binary_format::errors::PartialVMError"
                                                                              ]
                                                                            |),
                                                                            [ err ]
                                                                          |)
                                                                        ]
                                                                    |)
                                                                  ]
                                                                |)
                                                              ]
                                                            |)
                                                          |)
                                                        |)));
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (M.alloc (|
                                                          M.never_to_any (|
                                                            M.read (|
                                                              M.return_ (|
                                                                Value.StructTuple
                                                                  "core::result::Result::Err"
                                                                  [ M.read (| err |) ]
                                                              |)
                                                            |)
                                                          |)
                                                        |)))
                                                  ]
                                                |)))
                                          ]
                                        |)
                                      |) in
                                    let~ operand2 :=
                                      M.copy (|
                                        M.match_operator (|
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.apply
                                                  (Ty.path "move_abstract_stack::AbstractStack")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_binary_format::file_format::SignatureToken"
                                                  ],
                                                "pop",
                                                []
                                              |),
                                              [
                                                M.SubPointer.get_struct_record_field (|
                                                  M.read (| verifier |),
                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "stack"
                                                |)
                                              ]
                                            |)
                                          |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Ok",
                                                    0
                                                  |) in
                                                let x := M.copy (| γ0_0 |) in
                                                x));
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_struct_tuple_field (|
                                                    γ,
                                                    "core::result::Result::Err",
                                                    0
                                                  |) in
                                                let e := M.copy (| γ0_0 |) in
                                                let~ err :=
                                                  M.alloc (|
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path
                                                          "move_binary_format::errors::PartialVMError",
                                                        "with_message",
                                                        []
                                                      |),
                                                      [
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_binary_format::errors::PartialVMError",
                                                            "new",
                                                            []
                                                          |),
                                                          [
                                                            Value.StructTuple
                                                              "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                              []
                                                          ]
                                                        |);
                                                        M.call_closure (|
                                                          M.get_function (|
                                                            "core::hint::must_use",
                                                            [ Ty.path "alloc::string::String" ]
                                                          |),
                                                          [
                                                            M.read (|
                                                              let~ res :=
                                                                M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_function (|
                                                                      "alloc::fmt::format",
                                                                      []
                                                                    |),
                                                                    [
                                                                      M.call_closure (|
                                                                        M.get_associated_function (|
                                                                          Ty.path
                                                                            "core::fmt::Arguments",
                                                                          "new_v1_formatted",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.read (|
                                                                                  Value.String
                                                                                    "crates/move-bytecode-verifier/src/type_safety.rs:772 "
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Argument",
                                                                                    "new_display",
                                                                                    [
                                                                                      Ty.path
                                                                                        "move_abstract_stack::AbsStackError"
                                                                                    ]
                                                                                  |),
                                                                                  [ e ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.call_closure (|
                                                                                  M.get_associated_function (|
                                                                                    Ty.path
                                                                                      "core::fmt::rt::Placeholder",
                                                                                    "new",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    Value.Integer
                                                                                      IntegerKind.Usize
                                                                                      0;
                                                                                    Value.UnicodeChar
                                                                                      32;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Alignment::Unknown"
                                                                                      [];
                                                                                    Value.Integer
                                                                                      IntegerKind.U32
                                                                                      4;
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      [];
                                                                                    Value.StructTuple
                                                                                      "core::fmt::rt::Count::Implied"
                                                                                      []
                                                                                  ]
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::UnsafeArg",
                                                                              "new",
                                                                              []
                                                                            |),
                                                                            []
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |) in
                                                              res
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) in
                                                M.match_operator (|
                                                  M.alloc (| Value.Tuple [] |),
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let γ :=
                                                          M.use (M.alloc (| Value.Bool true |)) in
                                                        let _ :=
                                                          M.is_constant_or_break_match (|
                                                            M.read (| γ |),
                                                            Value.Bool true
                                                          |) in
                                                        M.alloc (|
                                                          M.never_to_any (|
                                                            M.call_closure (|
                                                              M.get_function (|
                                                                "core::panicking::panic_fmt",
                                                                []
                                                              |),
                                                              [
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.path "core::fmt::Arguments",
                                                                    "new_v1",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.read (|
                                                                            Value.String ""
                                                                          |)
                                                                        ]
                                                                    |);
                                                                    M.alloc (|
                                                                      Value.Array
                                                                        [
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::Argument",
                                                                              "new_debug",
                                                                              [
                                                                                Ty.path
                                                                                  "move_binary_format::errors::PartialVMError"
                                                                              ]
                                                                            |),
                                                                            [ err ]
                                                                          |)
                                                                        ]
                                                                    |)
                                                                  ]
                                                                |)
                                                              ]
                                                            |)
                                                          |)
                                                        |)));
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (M.alloc (|
                                                          M.never_to_any (|
                                                            M.read (|
                                                              M.return_ (|
                                                                Value.StructTuple
                                                                  "core::result::Result::Err"
                                                                  [ M.read (| err |) ]
                                                              |)
                                                            |)
                                                          |)
                                                        |)))
                                                  ]
                                                |)))
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  LogicalOp.and (|
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path
                                                          "move_binary_format::file_format::SignatureToken",
                                                        "is_integer",
                                                        []
                                                      |),
                                                      [ operand1 ]
                                                    |),
                                                    ltac:(M.monadic
                                                      (M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.path
                                                            "move_binary_format::file_format::SignatureToken",
                                                          [
                                                            Ty.path
                                                              "move_binary_format::file_format::SignatureToken"
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [ operand1; operand2 ]
                                                      |)))
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) 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_associated_function (|
                                                        Ty.path
                                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                        "push",
                                                        [ impl_Meter__plus___Sized ]
                                                      |),
                                                      [
                                                        M.read (| verifier |);
                                                        M.read (| meter |);
                                                        Value.StructTuple
                                                          "move_binary_format::file_format::SignatureToken::Bool"
                                                          []
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |),
                                              [
                                                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))
                                              ]
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                            "error",
                                                            []
                                                          |),
                                                          [
                                                            M.read (| verifier |);
                                                            Value.StructTuple
                                                              "move_core_types::vm_status::StatusCode::INTEGER_OP_TYPE_MISMATCH_ERROR"
                                                              [];
                                                            M.read (| offset |)
                                                          ]
                                                        |)
                                                      ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                                | _ => M.impossible "wrong number of arguments"
                                end))
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::MutBorrowGlobalDeprecated",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) 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_function (|
                                    "move_bytecode_verifier::type_safety::borrow_global",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| offset |);
                                    Value.Bool true;
                                    M.read (| M.read (| idx |) |);
                                    M.alloc (|
                                      Value.StructTuple
                                        "move_binary_format::file_format::Signature"
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.apply
                                                (Ty.path "alloc::vec::Vec")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::SignatureToken";
                                                  Ty.path "alloc::alloc::Global"
                                                ],
                                              "new",
                                              []
                                            |),
                                            []
                                          |)
                                        ]
                                    |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::MutBorrowGlobalGenericDeprecated",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ struct_inst :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "struct_instantiation_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| idx |) |)
                              ]
                            |)
                          |) in
                        let~ type_inst :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "signature_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| struct_inst |),
                                    "move_binary_format::file_format::StructDefInstantiation",
                                    "type_parameters"
                                  |)
                                |)
                              ]
                            |)
                          |) 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_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "charge_tys",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::ops::deref::Deref",
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken";
                                              Ty.path "alloc::alloc::Global"
                                            ],
                                          [],
                                          "deref",
                                          []
                                        |),
                                        [
                                          M.SubPointer.get_struct_tuple_field (|
                                            M.read (| type_inst |),
                                            "move_binary_format::file_format::Signature",
                                            0
                                          |)
                                        ]
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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_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_function (|
                                    "move_bytecode_verifier::type_safety::borrow_global",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| offset |);
                                    Value.Bool true;
                                    M.read (|
                                      M.SubPointer.get_struct_record_field (|
                                        M.read (| struct_inst |),
                                        "move_binary_format::file_format::StructDefInstantiation",
                                        "def"
                                      |)
                                    |);
                                    M.read (| type_inst |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::ImmBorrowGlobalDeprecated",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) 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_function (|
                                    "move_bytecode_verifier::type_safety::borrow_global",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| offset |);
                                    Value.Bool false;
                                    M.read (| M.read (| idx |) |);
                                    M.alloc (|
                                      Value.StructTuple
                                        "move_binary_format::file_format::Signature"
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.apply
                                                (Ty.path "alloc::vec::Vec")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::SignatureToken";
                                                  Ty.path "alloc::alloc::Global"
                                                ],
                                              "new",
                                              []
                                            |),
                                            []
                                          |)
                                        ]
                                    |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::ImmBorrowGlobalGenericDeprecated",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ struct_inst :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "struct_instantiation_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| idx |) |)
                              ]
                            |)
                          |) in
                        let~ type_inst :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "signature_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| struct_inst |),
                                    "move_binary_format::file_format::StructDefInstantiation",
                                    "type_parameters"
                                  |)
                                |)
                              ]
                            |)
                          |) 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_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "charge_tys",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::ops::deref::Deref",
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken";
                                              Ty.path "alloc::alloc::Global"
                                            ],
                                          [],
                                          "deref",
                                          []
                                        |),
                                        [
                                          M.SubPointer.get_struct_tuple_field (|
                                            M.read (| type_inst |),
                                            "move_binary_format::file_format::Signature",
                                            0
                                          |)
                                        ]
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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_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_function (|
                                    "move_bytecode_verifier::type_safety::borrow_global",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| offset |);
                                    Value.Bool false;
                                    M.read (|
                                      M.SubPointer.get_struct_record_field (|
                                        M.read (| struct_inst |),
                                        "move_binary_format::file_format::StructDefInstantiation",
                                        "def"
                                      |)
                                    |);
                                    M.read (| type_inst |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::ExistsDeprecated",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ struct_def :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "struct_def_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| idx |) |)
                              ]
                            |)
                          |) 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_function (|
                                    "move_bytecode_verifier::type_safety::exists",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| offset |);
                                    M.read (| struct_def |);
                                    M.alloc (|
                                      Value.StructTuple
                                        "move_binary_format::file_format::Signature"
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.apply
                                                (Ty.path "alloc::vec::Vec")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::SignatureToken";
                                                  Ty.path "alloc::alloc::Global"
                                                ],
                                              "new",
                                              []
                                            |),
                                            []
                                          |)
                                        ]
                                    |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::ExistsGenericDeprecated",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ struct_inst :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "struct_instantiation_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| idx |) |)
                              ]
                            |)
                          |) in
                        let~ struct_def :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "struct_def_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| struct_inst |),
                                    "move_binary_format::file_format::StructDefInstantiation",
                                    "def"
                                  |)
                                |)
                              ]
                            |)
                          |) in
                        let~ type_args :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "signature_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| struct_inst |),
                                    "move_binary_format::file_format::StructDefInstantiation",
                                    "type_parameters"
                                  |)
                                |)
                              ]
                            |)
                          |) 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_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "charge_tys",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::ops::deref::Deref",
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken";
                                              Ty.path "alloc::alloc::Global"
                                            ],
                                          [],
                                          "deref",
                                          []
                                        |),
                                        [
                                          M.SubPointer.get_struct_tuple_field (|
                                            M.read (| type_args |),
                                            "move_binary_format::file_format::Signature",
                                            0
                                          |)
                                        ]
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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_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_function (|
                                    "move_bytecode_verifier::type_safety::exists",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| offset |);
                                    M.read (| struct_def |);
                                    M.read (| type_args |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::MoveFromDeprecated",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ struct_def :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "struct_def_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| idx |) |)
                              ]
                            |)
                          |) 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_function (|
                                    "move_bytecode_verifier::type_safety::move_from",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| offset |);
                                    M.read (| struct_def |);
                                    M.alloc (|
                                      Value.StructTuple
                                        "move_binary_format::file_format::Signature"
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.apply
                                                (Ty.path "alloc::vec::Vec")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::SignatureToken";
                                                  Ty.path "alloc::alloc::Global"
                                                ],
                                              "new",
                                              []
                                            |),
                                            []
                                          |)
                                        ]
                                    |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::MoveFromGenericDeprecated",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ struct_inst :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "struct_instantiation_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| idx |) |)
                              ]
                            |)
                          |) in
                        let~ struct_def :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "struct_def_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| struct_inst |),
                                    "move_binary_format::file_format::StructDefInstantiation",
                                    "def"
                                  |)
                                |)
                              ]
                            |)
                          |) in
                        let~ type_args :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "signature_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| struct_inst |),
                                    "move_binary_format::file_format::StructDefInstantiation",
                                    "type_parameters"
                                  |)
                                |)
                              ]
                            |)
                          |) 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_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "charge_tys",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::ops::deref::Deref",
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken";
                                              Ty.path "alloc::alloc::Global"
                                            ],
                                          [],
                                          "deref",
                                          []
                                        |),
                                        [
                                          M.SubPointer.get_struct_tuple_field (|
                                            M.read (| type_args |),
                                            "move_binary_format::file_format::Signature",
                                            0
                                          |)
                                        ]
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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_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_function (|
                                    "move_bytecode_verifier::type_safety::move_from",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| offset |);
                                    M.read (| struct_def |);
                                    M.read (| type_args |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::MoveToDeprecated",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ struct_def :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "struct_def_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| idx |) |)
                              ]
                            |)
                          |) 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_function (|
                                    "move_bytecode_verifier::type_safety::move_to",
                                    []
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| offset |);
                                    M.read (| struct_def |);
                                    M.alloc (|
                                      Value.StructTuple
                                        "move_binary_format::file_format::Signature"
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.apply
                                                (Ty.path "alloc::vec::Vec")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::SignatureToken";
                                                  Ty.path "alloc::alloc::Global"
                                                ],
                                              "new",
                                              []
                                            |),
                                            []
                                          |)
                                        ]
                                    |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::MoveToGenericDeprecated",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ struct_inst :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "struct_instantiation_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| idx |) |)
                              ]
                            |)
                          |) in
                        let~ struct_def :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "struct_def_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| struct_inst |),
                                    "move_binary_format::file_format::StructDefInstantiation",
                                    "def"
                                  |)
                                |)
                              ]
                            |)
                          |) in
                        let~ type_args :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "move_binary_format::file_format::CompiledModule",
                                "signature_at",
                                []
                              |),
                              [
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| verifier |),
                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                    "module"
                                  |)
                                |);
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| struct_inst |),
                                    "move_binary_format::file_format::StructDefInstantiation",
                                    "type_parameters"
                                  |)
                                |)
                              ]
                            |)
                          |) 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_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "charge_tys",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::ops::deref::Deref",
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken";
                                              Ty.path "alloc::alloc::Global"
                                            ],
                                          [],
                                          "deref",
                                          []
                                        |),
                                        [
                                          M.SubPointer.get_struct_tuple_field (|
                                            M.read (| type_args |),
                                            "move_binary_format::file_format::Signature",
                                            0
                                          |)
                                        ]
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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_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_function (|
                                    "move_bytecode_verifier::type_safety::move_to",
                                    []
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| offset |);
                                    M.read (| struct_def |);
                                    M.read (| type_args |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::VecPack",
                            0
                          |) in
                        let γ1_1 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::VecPack",
                            1
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let num := M.alloc (| γ1_1 |) in
                        let~ element_type :=
                          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::SignatureToken";
                                    Ty.path "alloc::alloc::Global"
                                  ],
                                [ Ty.path "usize" ],
                                "index",
                                []
                              |),
                              [
                                M.SubPointer.get_struct_tuple_field (|
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::file_format::CompiledModule",
                                      "signature_at",
                                      []
                                    |),
                                    [
                                      M.read (|
                                        M.SubPointer.get_struct_record_field (|
                                          M.read (| verifier |),
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                          "module"
                                        |)
                                      |);
                                      M.read (| M.read (| idx |) |)
                                    ]
                                  |),
                                  "move_binary_format::file_format::Signature",
                                  0
                                |);
                                Value.Integer IntegerKind.Usize 0
                              ]
                            |)
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ :=
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.apply
                                            (Ty.path "core::num::nonzero::NonZero")
                                            []
                                            [ Ty.path "u64" ],
                                          "new",
                                          []
                                        |),
                                        [ M.read (| M.read (| num |) |) ]
                                      |)
                                    |) in
                                  let γ0_0 :=
                                    M.SubPointer.get_struct_tuple_field (|
                                      γ,
                                      "core::option::Option::Some",
                                      0
                                    |) in
                                  let num_to_pop := M.copy (| γ0_0 |) in
                                  let~ is_mismatched :=
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.apply
                                            (Ty.path "core::result::Result")
                                            []
                                            [
                                              Ty.path "bool";
                                              Ty.path "move_abstract_stack::AbsStackError"
                                            ],
                                          "unwrap_or",
                                          []
                                        |),
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.apply
                                                (Ty.path "core::result::Result")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::SignatureToken";
                                                  Ty.path "move_abstract_stack::AbsStackError"
                                                ],
                                              "map",
                                              [
                                                Ty.path "bool";
                                                Ty.function
                                                  [
                                                    Ty.tuple
                                                      [
                                                        Ty.path
                                                          "move_binary_format::file_format::SignatureToken"
                                                      ]
                                                  ]
                                                  (Ty.path "bool")
                                              ]
                                            |),
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.apply
                                                    (Ty.path "move_abstract_stack::AbstractStack")
                                                    []
                                                    [
                                                      Ty.path
                                                        "move_binary_format::file_format::SignatureToken"
                                                    ],
                                                  "pop_eq_n",
                                                  []
                                                |),
                                                [
                                                  M.SubPointer.get_struct_record_field (|
                                                    M.read (| verifier |),
                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                    "stack"
                                                  |);
                                                  M.read (| num_to_pop |)
                                                ]
                                              |);
                                              M.closure
                                                (fun γ =>
                                                  ltac:(M.monadic
                                                    match γ with
                                                    | [ α0 ] =>
                                                      ltac:(M.monadic
                                                        (M.match_operator (|
                                                          M.alloc (| α0 |),
                                                          [
                                                            fun γ =>
                                                              ltac:(M.monadic
                                                                (let t := M.copy (| γ |) in
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialEq",
                                                                    Ty.apply
                                                                      (Ty.path "&")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "move_binary_format::file_format::SignatureToken"
                                                                      ],
                                                                    [
                                                                      Ty.apply
                                                                        (Ty.path "&")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "move_binary_format::file_format::SignatureToken"
                                                                        ]
                                                                    ],
                                                                    "ne",
                                                                    []
                                                                  |),
                                                                  [ element_type; M.alloc (| t |) ]
                                                                |)))
                                                          ]
                                                        |)))
                                                    | _ => M.impossible "wrong number of arguments"
                                                    end))
                                            ]
                                          |);
                                          Value.Bool true
                                        ]
                                      |)
                                    |) in
                                  M.match_operator (|
                                    M.alloc (| Value.Tuple [] |),
                                    [
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let γ := M.use is_mismatched in
                                          let _ :=
                                            M.is_constant_or_break_match (|
                                              M.read (| γ |),
                                              Value.Bool true
                                            |) in
                                          M.alloc (|
                                            M.never_to_any (|
                                              M.read (|
                                                M.return_ (|
                                                  Value.StructTuple
                                                    "core::result::Result::Err"
                                                    [
                                                      M.call_closure (|
                                                        M.get_associated_function (|
                                                          Ty.path
                                                            "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                          "error",
                                                          []
                                                        |),
                                                        [
                                                          M.read (| verifier |);
                                                          Value.StructTuple
                                                            "move_core_types::vm_status::StatusCode::TYPE_MISMATCH"
                                                            [];
                                                          M.read (| offset |)
                                                        ]
                                                      |)
                                                    ]
                                                |)
                                              |)
                                            |)
                                          |)));
                                      fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                    ]
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::ops::try_trait::Try",
                                  Ty.apply
                                    (Ty.path "core::result::Result")
                                    []
                                    [
                                      Ty.tuple [];
                                      Ty.path "move_binary_format::errors::PartialVMError"
                                    ],
                                  [],
                                  "branch",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "push",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      Value.StructTuple
                                        "move_binary_format::file_format::SignatureToken::Vector"
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.apply
                                                (Ty.path "alloc::boxed::Box")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::SignatureToken";
                                                  Ty.path "alloc::alloc::Global"
                                                ],
                                              "new",
                                              []
                                            |),
                                            [
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::clone::Clone",
                                                  Ty.path
                                                    "move_binary_format::file_format::SignatureToken",
                                                  [],
                                                  "clone",
                                                  []
                                                |),
                                                [ M.read (| element_type |) ]
                                              |)
                                            ]
                                          |)
                                        ]
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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.alloc (| Value.Tuple [] |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::VecLen",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ operand :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:857 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        let~ declared_element_type :=
                          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::SignatureToken";
                                    Ty.path "alloc::alloc::Global"
                                  ],
                                [ Ty.path "usize" ],
                                "index",
                                []
                              |),
                              [
                                M.SubPointer.get_struct_tuple_field (|
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::file_format::CompiledModule",
                                      "signature_at",
                                      []
                                    |),
                                    [
                                      M.read (|
                                        M.SubPointer.get_struct_record_field (|
                                          M.read (| verifier |),
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                          "module"
                                        |)
                                      |);
                                      M.read (| M.read (| idx |) |)
                                    ]
                                  |),
                                  "move_binary_format::file_format::Signature",
                                  0
                                |);
                                Value.Integer IntegerKind.Usize 0
                              ]
                            |)
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (|
                              M.call_closure (|
                                M.get_function (|
                                  "move_bytecode_verifier::type_safety::get_vector_element_type",
                                  []
                                |),
                                [ M.read (| operand |); Value.Bool false ]
                              |)
                            |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ0_0 :=
                                    M.SubPointer.get_struct_tuple_field (|
                                      γ,
                                      "core::option::Option::Some",
                                      0
                                    |) in
                                  let derived_element_type := M.copy (| γ0_0 |) in
                                  let γ :=
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "&")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken"
                                            ],
                                          [
                                            Ty.apply
                                              (Ty.path "&")
                                              []
                                              [
                                                Ty.path
                                                  "move_binary_format::file_format::SignatureToken"
                                              ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [ M.alloc (| derived_element_type |); declared_element_type
                                        ]
                                      |)
                                    |) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) 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_associated_function (|
                                                Ty.path
                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                "push",
                                                [ impl_Meter__plus___Sized ]
                                              |),
                                              [
                                                M.read (| verifier |);
                                                M.read (| meter |);
                                                Value.StructTuple
                                                  "move_binary_format::file_format::SignatureToken::U64"
                                                  []
                                              ]
                                            |)
                                          ]
                                        |)
                                      |),
                                      [
                                        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.alloc (| Value.Tuple [] |)));
                              fun γ =>
                                ltac:(M.monadic
                                  (M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path
                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "error",
                                                  []
                                                |),
                                                [
                                                  M.read (| verifier |);
                                                  Value.StructTuple
                                                    "move_core_types::vm_status::StatusCode::TYPE_MISMATCH"
                                                    [];
                                                  M.read (| offset |)
                                                ]
                                              |)
                                            ]
                                        |)
                                      |)
                                    |)
                                  |)))
                            ]
                          |) in
                        M.alloc (| Value.Tuple [] |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::VecImmBorrow",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ declared_element_type :=
                          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::SignatureToken";
                                    Ty.path "alloc::alloc::Global"
                                  ],
                                [ Ty.path "usize" ],
                                "index",
                                []
                              |),
                              [
                                M.SubPointer.get_struct_tuple_field (|
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::file_format::CompiledModule",
                                      "signature_at",
                                      []
                                    |),
                                    [
                                      M.read (|
                                        M.SubPointer.get_struct_record_field (|
                                          M.read (| verifier |),
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                          "module"
                                        |)
                                      |);
                                      M.read (| M.read (| idx |) |)
                                    ]
                                  |),
                                  "move_binary_format::file_format::Signature",
                                  0
                                |);
                                Value.Integer IntegerKind.Usize 0
                              ]
                            |)
                          |) 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_function (|
                                    "move_bytecode_verifier::type_safety::borrow_vector_element",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| declared_element_type |);
                                    M.read (| offset |);
                                    Value.Bool false
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::VecMutBorrow",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ declared_element_type :=
                          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::SignatureToken";
                                    Ty.path "alloc::alloc::Global"
                                  ],
                                [ Ty.path "usize" ],
                                "index",
                                []
                              |),
                              [
                                M.SubPointer.get_struct_tuple_field (|
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::file_format::CompiledModule",
                                      "signature_at",
                                      []
                                    |),
                                    [
                                      M.read (|
                                        M.SubPointer.get_struct_record_field (|
                                          M.read (| verifier |),
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                          "module"
                                        |)
                                      |);
                                      M.read (| M.read (| idx |) |)
                                    ]
                                  |),
                                  "move_binary_format::file_format::Signature",
                                  0
                                |);
                                Value.Integer IntegerKind.Usize 0
                              ]
                            |)
                          |) 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_function (|
                                    "move_bytecode_verifier::type_safety::borrow_vector_element",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| meter |);
                                    M.read (| declared_element_type |);
                                    M.read (| offset |);
                                    Value.Bool true
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::VecPushBack",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ operand_elem :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:877 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        let~ operand_vec :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:878 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        let~ declared_element_type :=
                          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::SignatureToken";
                                    Ty.path "alloc::alloc::Global"
                                  ],
                                [ Ty.path "usize" ],
                                "index",
                                []
                              |),
                              [
                                M.SubPointer.get_struct_tuple_field (|
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::file_format::CompiledModule",
                                      "signature_at",
                                      []
                                    |),
                                    [
                                      M.read (|
                                        M.SubPointer.get_struct_record_field (|
                                          M.read (| verifier |),
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                          "module"
                                        |)
                                      |);
                                      M.read (| M.read (| idx |) |)
                                    ]
                                  |),
                                  "move_binary_format::file_format::Signature",
                                  0
                                |);
                                Value.Integer IntegerKind.Usize 0
                              ]
                            |)
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ :=
                                    M.use
                                      (M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialEq",
                                            Ty.apply
                                              (Ty.path "&")
                                              []
                                              [
                                                Ty.path
                                                  "move_binary_format::file_format::SignatureToken"
                                              ],
                                            [
                                              Ty.apply
                                                (Ty.path "&")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::SignatureToken"
                                                ]
                                            ],
                                            "ne",
                                            []
                                          |),
                                          [ declared_element_type; M.alloc (| operand_elem |) ]
                                        |)
                                      |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path
                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "error",
                                                  []
                                                |),
                                                [
                                                  M.read (| verifier |);
                                                  Value.StructTuple
                                                    "move_core_types::vm_status::StatusCode::TYPE_MISMATCH"
                                                    [];
                                                  M.read (| offset |)
                                                ]
                                              |)
                                            ]
                                        |)
                                      |)
                                    |)
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (|
                              M.call_closure (|
                                M.get_function (|
                                  "move_bytecode_verifier::type_safety::get_vector_element_type",
                                  []
                                |),
                                [ M.read (| operand_vec |); Value.Bool true ]
                              |)
                            |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ0_0 :=
                                    M.SubPointer.get_struct_tuple_field (|
                                      γ,
                                      "core::option::Option::Some",
                                      0
                                    |) in
                                  let derived_element_type := M.copy (| γ0_0 |) in
                                  let γ :=
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "&")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken"
                                            ],
                                          [
                                            Ty.apply
                                              (Ty.path "&")
                                              []
                                              [
                                                Ty.path
                                                  "move_binary_format::file_format::SignatureToken"
                                              ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [ M.alloc (| derived_element_type |); declared_element_type
                                        ]
                                      |)
                                    |) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (| Value.Tuple [] |)));
                              fun γ =>
                                ltac:(M.monadic
                                  (M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path
                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "error",
                                                  []
                                                |),
                                                [
                                                  M.read (| verifier |);
                                                  Value.StructTuple
                                                    "move_core_types::vm_status::StatusCode::TYPE_MISMATCH"
                                                    [];
                                                  M.read (| offset |)
                                                ]
                                              |)
                                            ]
                                        |)
                                      |)
                                    |)
                                  |)))
                            ]
                          |) in
                        M.alloc (| Value.Tuple [] |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::VecPopBack",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ operand_vec :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:890 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        let~ declared_element_type :=
                          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::SignatureToken";
                                    Ty.path "alloc::alloc::Global"
                                  ],
                                [ Ty.path "usize" ],
                                "index",
                                []
                              |),
                              [
                                M.SubPointer.get_struct_tuple_field (|
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::file_format::CompiledModule",
                                      "signature_at",
                                      []
                                    |),
                                    [
                                      M.read (|
                                        M.SubPointer.get_struct_record_field (|
                                          M.read (| verifier |),
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                          "module"
                                        |)
                                      |);
                                      M.read (| M.read (| idx |) |)
                                    ]
                                  |),
                                  "move_binary_format::file_format::Signature",
                                  0
                                |);
                                Value.Integer IntegerKind.Usize 0
                              ]
                            |)
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (|
                              M.call_closure (|
                                M.get_function (|
                                  "move_bytecode_verifier::type_safety::get_vector_element_type",
                                  []
                                |),
                                [ M.read (| operand_vec |); Value.Bool true ]
                              |)
                            |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ0_0 :=
                                    M.SubPointer.get_struct_tuple_field (|
                                      γ,
                                      "core::option::Option::Some",
                                      0
                                    |) in
                                  let derived_element_type := M.copy (| γ0_0 |) in
                                  let γ :=
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "&")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken"
                                            ],
                                          [
                                            Ty.apply
                                              (Ty.path "&")
                                              []
                                              [
                                                Ty.path
                                                  "move_binary_format::file_format::SignatureToken"
                                              ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [ M.alloc (| derived_element_type |); declared_element_type
                                        ]
                                      |)
                                    |) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) 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_associated_function (|
                                                Ty.path
                                                  "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                "push",
                                                [ impl_Meter__plus___Sized ]
                                              |),
                                              [
                                                M.read (| verifier |);
                                                M.read (| meter |);
                                                M.read (| derived_element_type |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |),
                                      [
                                        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.alloc (| Value.Tuple [] |)));
                              fun γ =>
                                ltac:(M.monadic
                                  (M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path
                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "error",
                                                  []
                                                |),
                                                [
                                                  M.read (| verifier |);
                                                  Value.StructTuple
                                                    "move_core_types::vm_status::StatusCode::TYPE_MISMATCH"
                                                    [];
                                                  M.read (| offset |)
                                                ]
                                              |)
                                            ]
                                        |)
                                      |)
                                    |)
                                  |)))
                            ]
                          |) in
                        M.alloc (| Value.Tuple [] |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::VecUnpack",
                            0
                          |) in
                        let γ1_1 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::VecUnpack",
                            1
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let num := M.alloc (| γ1_1 |) in
                        let~ operand_vec :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:901 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        let~ declared_element_type :=
                          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::SignatureToken";
                                    Ty.path "alloc::alloc::Global"
                                  ],
                                [ Ty.path "usize" ],
                                "index",
                                []
                              |),
                              [
                                M.SubPointer.get_struct_tuple_field (|
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::file_format::CompiledModule",
                                      "signature_at",
                                      []
                                    |),
                                    [
                                      M.read (|
                                        M.SubPointer.get_struct_record_field (|
                                          M.read (| verifier |),
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                          "module"
                                        |)
                                      |);
                                      M.read (| M.read (| idx |) |)
                                    ]
                                  |),
                                  "move_binary_format::file_format::Signature",
                                  0
                                |);
                                Value.Integer IntegerKind.Usize 0
                              ]
                            |)
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ :=
                                    M.use
                                      (M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialEq",
                                            Ty.path
                                              "move_binary_format::file_format::SignatureToken",
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken"
                                            ],
                                            "ne",
                                            []
                                          |),
                                          [
                                            operand_vec;
                                            M.alloc (|
                                              Value.StructTuple
                                                "move_binary_format::file_format::SignatureToken::Vector"
                                                [
                                                  M.call_closure (|
                                                    M.get_associated_function (|
                                                      Ty.apply
                                                        (Ty.path "alloc::boxed::Box")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_binary_format::file_format::SignatureToken";
                                                          Ty.path "alloc::alloc::Global"
                                                        ],
                                                      "new",
                                                      []
                                                    |),
                                                    [
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::clone::Clone",
                                                          Ty.path
                                                            "move_binary_format::file_format::SignatureToken",
                                                          [],
                                                          "clone",
                                                          []
                                                        |),
                                                        [ M.read (| declared_element_type |) ]
                                                      |)
                                                    ]
                                                  |)
                                                ]
                                            |)
                                          ]
                                        |)
                                      |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path
                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "error",
                                                  []
                                                |),
                                                [
                                                  M.read (| verifier |);
                                                  Value.StructTuple
                                                    "move_core_types::vm_status::StatusCode::TYPE_MISMATCH"
                                                    [];
                                                  M.read (| offset |)
                                                ]
                                              |)
                                            ]
                                        |)
                                      |)
                                    |)
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::ops::try_trait::Try",
                                  Ty.apply
                                    (Ty.path "core::result::Result")
                                    []
                                    [
                                      Ty.tuple [];
                                      Ty.path "move_binary_format::errors::PartialVMError"
                                    ],
                                  [],
                                  "branch",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "push_n",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::clone::Clone",
                                          Ty.path "move_binary_format::file_format::SignatureToken",
                                          [],
                                          "clone",
                                          []
                                        |),
                                        [ M.read (| declared_element_type |) ]
                                      |);
                                      M.read (| M.read (| num |) |)
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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.alloc (| Value.Tuple [] |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::VecSwap",
                            0
                          |) in
                        let idx := M.alloc (| γ1_0 |) in
                        let~ operand_idx2 :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:910 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        let~ operand_idx1 :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:911 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        let~ operand_vec :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:912 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ :=
                                    M.use
                                      (M.alloc (|
                                        LogicalOp.or (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken",
                                              [
                                                Ty.path
                                                  "move_binary_format::file_format::SignatureToken"
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              operand_idx1;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "move_binary_format::file_format::SignatureToken::U64"
                                                  []
                                              |)
                                            ]
                                          |),
                                          ltac:(M.monadic
                                            (M.call_closure (|
                                              M.get_trait_method (|
                                                "core::cmp::PartialEq",
                                                Ty.path
                                                  "move_binary_format::file_format::SignatureToken",
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::SignatureToken"
                                                ],
                                                "ne",
                                                []
                                              |),
                                              [
                                                operand_idx2;
                                                M.alloc (|
                                                  Value.StructTuple
                                                    "move_binary_format::file_format::SignatureToken::U64"
                                                    []
                                                |)
                                              ]
                                            |)))
                                        |)
                                      |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path
                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "error",
                                                  []
                                                |),
                                                [
                                                  M.read (| verifier |);
                                                  Value.StructTuple
                                                    "move_core_types::vm_status::StatusCode::TYPE_MISMATCH"
                                                    [];
                                                  M.read (| offset |)
                                                ]
                                              |)
                                            ]
                                        |)
                                      |)
                                    |)
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) in
                        let~ declared_element_type :=
                          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::SignatureToken";
                                    Ty.path "alloc::alloc::Global"
                                  ],
                                [ Ty.path "usize" ],
                                "index",
                                []
                              |),
                              [
                                M.SubPointer.get_struct_tuple_field (|
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "move_binary_format::file_format::CompiledModule",
                                      "signature_at",
                                      []
                                    |),
                                    [
                                      M.read (|
                                        M.SubPointer.get_struct_record_field (|
                                          M.read (| verifier |),
                                          "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                          "module"
                                        |)
                                      |);
                                      M.read (| M.read (| idx |) |)
                                    ]
                                  |),
                                  "move_binary_format::file_format::Signature",
                                  0
                                |);
                                Value.Integer IntegerKind.Usize 0
                              ]
                            |)
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (|
                              M.call_closure (|
                                M.get_function (|
                                  "move_bytecode_verifier::type_safety::get_vector_element_type",
                                  []
                                |),
                                [ M.read (| operand_vec |); Value.Bool true ]
                              |)
                            |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ0_0 :=
                                    M.SubPointer.get_struct_tuple_field (|
                                      γ,
                                      "core::option::Option::Some",
                                      0
                                    |) in
                                  let derived_element_type := M.copy (| γ0_0 |) in
                                  let γ :=
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "&")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken"
                                            ],
                                          [
                                            Ty.apply
                                              (Ty.path "&")
                                              []
                                              [
                                                Ty.path
                                                  "move_binary_format::file_format::SignatureToken"
                                              ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [ M.alloc (| derived_element_type |); declared_element_type
                                        ]
                                      |)
                                    |) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (| Value.Tuple [] |)));
                              fun γ =>
                                ltac:(M.monadic
                                  (M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path
                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "error",
                                                  []
                                                |),
                                                [
                                                  M.read (| verifier |);
                                                  Value.StructTuple
                                                    "move_core_types::vm_status::StatusCode::TYPE_MISMATCH"
                                                    [];
                                                  M.read (| offset |)
                                                ]
                                              |)
                                            ]
                                        |)
                                      |)
                                    |)
                                  |)))
                            ]
                          |) in
                        M.alloc (| Value.Tuple [] |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (|
                            γ,
                            "move_binary_format::file_format::Bytecode::CastU16"
                          |) in
                        let~ operand :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:923 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ :=
                                    M.use
                                      (M.alloc (|
                                        UnOp.not (|
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken",
                                              "is_integer",
                                              []
                                            |),
                                            [ operand ]
                                          |)
                                        |)
                                      |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path
                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "error",
                                                  []
                                                |),
                                                [
                                                  M.read (| verifier |);
                                                  Value.StructTuple
                                                    "move_core_types::vm_status::StatusCode::INTEGER_OP_TYPE_MISMATCH_ERROR"
                                                    [];
                                                  M.read (| offset |)
                                                ]
                                              |)
                                            ]
                                        |)
                                      |)
                                    |)
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::ops::try_trait::Try",
                                  Ty.apply
                                    (Ty.path "core::result::Result")
                                    []
                                    [
                                      Ty.tuple [];
                                      Ty.path "move_binary_format::errors::PartialVMError"
                                    ],
                                  [],
                                  "branch",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "push",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      Value.StructTuple
                                        "move_binary_format::file_format::SignatureToken::U16"
                                        []
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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.alloc (| Value.Tuple [] |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (|
                            γ,
                            "move_binary_format::file_format::Bytecode::CastU32"
                          |) in
                        let~ operand :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:930 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ :=
                                    M.use
                                      (M.alloc (|
                                        UnOp.not (|
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken",
                                              "is_integer",
                                              []
                                            |),
                                            [ operand ]
                                          |)
                                        |)
                                      |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path
                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "error",
                                                  []
                                                |),
                                                [
                                                  M.read (| verifier |);
                                                  Value.StructTuple
                                                    "move_core_types::vm_status::StatusCode::INTEGER_OP_TYPE_MISMATCH_ERROR"
                                                    [];
                                                  M.read (| offset |)
                                                ]
                                              |)
                                            ]
                                        |)
                                      |)
                                    |)
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::ops::try_trait::Try",
                                  Ty.apply
                                    (Ty.path "core::result::Result")
                                    []
                                    [
                                      Ty.tuple [];
                                      Ty.path "move_binary_format::errors::PartialVMError"
                                    ],
                                  [],
                                  "branch",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "push",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      Value.StructTuple
                                        "move_binary_format::file_format::SignatureToken::U32"
                                        []
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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.alloc (| Value.Tuple [] |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (|
                            γ,
                            "move_binary_format::file_format::Bytecode::CastU256"
                          |) in
                        let~ operand :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "move_abstract_stack::AbstractStack")
                                      []
                                      [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "stack"
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Ok",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::result::Result::Err",
                                        0
                                      |) in
                                    let e := M.copy (| γ0_0 |) in
                                    let~ err :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "move_binary_format::errors::PartialVMError",
                                            "with_message",
                                            []
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path
                                                  "move_binary_format::errors::PartialVMError",
                                                "new",
                                                []
                                              |),
                                              [
                                                Value.StructTuple
                                                  "move_core_types::vm_status::StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR"
                                                  []
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::hint::must_use",
                                                [ Ty.path "alloc::string::String" ]
                                              |),
                                              [
                                                M.read (|
                                                  let~ res :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "alloc::fmt::format",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.path "core::fmt::Arguments",
                                                              "new_v1_formatted",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/type_safety.rs:937 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Argument",
                                                                        "new_display",
                                                                        [
                                                                          Ty.path
                                                                            "move_abstract_stack::AbsStackError"
                                                                        ]
                                                                      |),
                                                                      [ e ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "core::fmt::rt::Placeholder",
                                                                        "new",
                                                                        []
                                                                      |),
                                                                      [
                                                                        Value.Integer
                                                                          IntegerKind.Usize
                                                                          0;
                                                                        Value.UnicodeChar 32;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Alignment::Unknown"
                                                                          [];
                                                                        Value.Integer
                                                                          IntegerKind.U32
                                                                          4;
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          [];
                                                                        Value.StructTuple
                                                                          "core::fmt::rt::Count::Implied"
                                                                          []
                                                                      ]
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path
                                                                    "core::fmt::rt::UnsafeArg",
                                                                  "new",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) in
                                                  res
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.never_to_any (|
                                                M.call_closure (|
                                                  M.get_function (|
                                                    "core::panicking::panic_fmt",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Arguments",
                                                        "new_v1",
                                                        []
                                                      |),
                                                      [
                                                        M.alloc (|
                                                          Value.Array
                                                            [ M.read (| Value.String "" |) ]
                                                        |);
                                                        M.alloc (|
                                                          Value.Array
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "new_debug",
                                                                  [
                                                                    Ty.path
                                                                      "move_binary_format::errors::PartialVMError"
                                                                  ]
                                                                |),
                                                                [ err ]
                                                              |)
                                                            ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.never_to_any (|
                                                M.read (|
                                                  M.return_ (|
                                                    Value.StructTuple
                                                      "core::result::Result::Err"
                                                      [ M.read (| err |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ :=
                                    M.use
                                      (M.alloc (|
                                        UnOp.not (|
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path
                                                "move_binary_format::file_format::SignatureToken",
                                              "is_integer",
                                              []
                                            |),
                                            [ operand ]
                                          |)
                                        |)
                                      |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.never_to_any (|
                                      M.read (|
                                        M.return_ (|
                                          Value.StructTuple
                                            "core::result::Result::Err"
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path
                                                    "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                                  "error",
                                                  []
                                                |),
                                                [
                                                  M.read (| verifier |);
                                                  Value.StructTuple
                                                    "move_core_types::vm_status::StatusCode::INTEGER_OP_TYPE_MISMATCH_ERROR"
                                                    [];
                                                  M.read (| offset |)
                                                ]
                                              |)
                                            ]
                                        |)
                                      |)
                                    |)
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) in
                        let~ _ :=
                          M.match_operator (|
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::ops::try_trait::Try",
                                  Ty.apply
                                    (Ty.path "core::result::Result")
                                    []
                                    [
                                      Ty.tuple [];
                                      Ty.path "move_binary_format::errors::PartialVMError"
                                    ],
                                  [],
                                  "branch",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path
                                        "move_bytecode_verifier::type_safety::TypeSafetyChecker",
                                      "push",
                                      [ impl_Meter__plus___Sized ]
                                    |),
                                    [
                                      M.read (| verifier |);
                                      M.read (| meter |);
                                      Value.StructTuple
                                        "move_binary_format::file_format::SignatureToken::U256"
                                        []
                                    ]
                                  |)
                                ]
                              |)
                            |),
                            [
                              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.alloc (| Value.Tuple [] |)))
                  ]
                |) in
              M.alloc (| Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ] |)
            |)))
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_verify_instr :
    M.IsFunction "move_bytecode_verifier::type_safety::verify_instr" verify_instr.
  
  (*
  fn materialize_type(struct_handle: StructHandleIndex, type_args: &Signature) -> SignatureToken {
      if type_args.is_empty() {
          ST::Struct(struct_handle)
      } else {
          ST::StructInstantiation(Box::new((struct_handle, type_args.0.clone())))
      }
  }
  *)
  Definition materialize_type (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [], [ struct_handle; type_args ] =>
      ltac:(M.monadic
        (let struct_handle := M.alloc (| struct_handle |) in
        let type_args := M.alloc (| type_args |) in
        M.read (|
          M.match_operator (|
            M.alloc (| Value.Tuple [] |),
            [
              fun γ =>
                ltac:(M.monadic
                  (let γ :=
                    M.use
                      (M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "move_binary_format::file_format::Signature",
                            "is_empty",
                            []
                          |),
                          [ M.read (| type_args |) ]
                        |)
                      |)) in
                  let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                  M.alloc (|
                    Value.StructTuple
                      "move_binary_format::file_format::SignatureToken::Struct"
                      [ M.read (| struct_handle |) ]
                  |)));
              fun γ =>
                ltac:(M.monadic
                  (M.alloc (|
                    Value.StructTuple
                      "move_binary_format::file_format::SignatureToken::StructInstantiation"
                      [
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.apply
                              (Ty.path "alloc::boxed::Box")
                              []
                              [
                                Ty.tuple
                                  [
                                    Ty.path "move_binary_format::file_format::StructHandleIndex";
                                    Ty.apply
                                      (Ty.path "alloc::vec::Vec")
                                      []
                                      [
                                        Ty.path "move_binary_format::file_format::SignatureToken";
                                        Ty.path "alloc::alloc::Global"
                                      ]
                                  ];
                                Ty.path "alloc::alloc::Global"
                              ],
                            "new",
                            []
                          |),
                          [
                            Value.Tuple
                              [
                                M.read (| struct_handle |);
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::clone::Clone",
                                    Ty.apply
                                      (Ty.path "alloc::vec::Vec")
                                      []
                                      [
                                        Ty.path "move_binary_format::file_format::SignatureToken";
                                        Ty.path "alloc::alloc::Global"
                                      ],
                                    [],
                                    "clone",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_tuple_field (|
                                      M.read (| type_args |),
                                      "move_binary_format::file_format::Signature",
                                      0
                                    |)
                                  ]
                                |)
                              ]
                          ]
                        |)
                      ]
                  |)))
            ]
          |)
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_materialize_type :
    M.IsFunction "move_bytecode_verifier::type_safety::materialize_type" materialize_type.
  
  (*
  fn instantiate(token: &SignatureToken, subst: &Signature) -> SignatureToken {
      use SignatureToken::*;
  
      if subst.0.is_empty() {
          return token.clone();
      }
  
      match token {
          Bool => Bool,
          U8 => U8,
          U16 => U16,
          U32 => U32,
          U64 => U64,
          U128 => U128,
          U256 => U256,
          Address => Address,
          Signer => Signer,
          Vector(ty) => Vector(Box::new(instantiate(ty, subst))),
          Struct(idx) => Struct( *idx),
          StructInstantiation(struct_inst) => {
              let (idx, struct_type_args) = &**struct_inst;
              StructInstantiation(Box::new((
                  *idx,
                  struct_type_args
                      .iter()
                      .map(|ty| instantiate(ty, subst))
                      .collect(),
              )))
          }
          Reference(ty) => Reference(Box::new(instantiate(ty, subst))),
          MutableReference(ty) => MutableReference(Box::new(instantiate(ty, subst))),
          TypeParameter(idx) => {
              // Assume that the caller has previously parsed and verified the structure of the
              // file and that this guarantees that type parameter indices are always in bounds.
              debug_assert!(( *idx as usize) < subst.len());
              subst.0[*idx as usize].clone()
          }
      }
  }
  *)
  Definition instantiate (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [], [ token; subst ] =>
      ltac:(M.monadic
        (let token := M.alloc (| token |) in
        let subst := M.alloc (| subst |) in
        M.catch_return (|
          ltac:(M.monadic
            (M.read (|
              let~ _ :=
                M.match_operator (|
                  M.alloc (| Value.Tuple [] |),
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ :=
                          M.use
                            (M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.apply
                                    (Ty.path "alloc::vec::Vec")
                                    []
                                    [
                                      Ty.path "move_binary_format::file_format::SignatureToken";
                                      Ty.path "alloc::alloc::Global"
                                    ],
                                  "is_empty",
                                  []
                                |),
                                [
                                  M.SubPointer.get_struct_tuple_field (|
                                    M.read (| subst |),
                                    "move_binary_format::file_format::Signature",
                                    0
                                  |)
                                ]
                              |)
                            |)) in
                        let _ :=
                          M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                        M.alloc (|
                          M.never_to_any (|
                            M.read (|
                              M.return_ (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::clone::Clone",
                                    Ty.path "move_binary_format::file_format::SignatureToken",
                                    [],
                                    "clone",
                                    []
                                  |),
                                  [ M.read (| token |) ]
                                |)
                              |)
                            |)
                          |)
                        |)));
                    fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                  ]
                |) in
              M.match_operator (|
                token,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let _ :=
                        M.is_struct_tuple (|
                          γ,
                          "move_binary_format::file_format::SignatureToken::Bool"
                        |) in
                      M.alloc (|
                        Value.StructTuple "move_binary_format::file_format::SignatureToken::Bool" []
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let _ :=
                        M.is_struct_tuple (|
                          γ,
                          "move_binary_format::file_format::SignatureToken::U8"
                        |) in
                      M.alloc (|
                        Value.StructTuple "move_binary_format::file_format::SignatureToken::U8" []
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let _ :=
                        M.is_struct_tuple (|
                          γ,
                          "move_binary_format::file_format::SignatureToken::U16"
                        |) in
                      M.alloc (|
                        Value.StructTuple "move_binary_format::file_format::SignatureToken::U16" []
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let _ :=
                        M.is_struct_tuple (|
                          γ,
                          "move_binary_format::file_format::SignatureToken::U32"
                        |) in
                      M.alloc (|
                        Value.StructTuple "move_binary_format::file_format::SignatureToken::U32" []
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let _ :=
                        M.is_struct_tuple (|
                          γ,
                          "move_binary_format::file_format::SignatureToken::U64"
                        |) in
                      M.alloc (|
                        Value.StructTuple "move_binary_format::file_format::SignatureToken::U64" []
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let _ :=
                        M.is_struct_tuple (|
                          γ,
                          "move_binary_format::file_format::SignatureToken::U128"
                        |) in
                      M.alloc (|
                        Value.StructTuple "move_binary_format::file_format::SignatureToken::U128" []
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let _ :=
                        M.is_struct_tuple (|
                          γ,
                          "move_binary_format::file_format::SignatureToken::U256"
                        |) in
                      M.alloc (|
                        Value.StructTuple "move_binary_format::file_format::SignatureToken::U256" []
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let _ :=
                        M.is_struct_tuple (|
                          γ,
                          "move_binary_format::file_format::SignatureToken::Address"
                        |) in
                      M.alloc (|
                        Value.StructTuple
                          "move_binary_format::file_format::SignatureToken::Address"
                          []
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let _ :=
                        M.is_struct_tuple (|
                          γ,
                          "move_binary_format::file_format::SignatureToken::Signer"
                        |) in
                      M.alloc (|
                        Value.StructTuple
                          "move_binary_format::file_format::SignatureToken::Signer"
                          []
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "move_binary_format::file_format::SignatureToken::Vector",
                          0
                        |) in
                      let ty := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        Value.StructTuple
                          "move_binary_format::file_format::SignatureToken::Vector"
                          [
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.apply
                                  (Ty.path "alloc::boxed::Box")
                                  []
                                  [
                                    Ty.path "move_binary_format::file_format::SignatureToken";
                                    Ty.path "alloc::alloc::Global"
                                  ],
                                "new",
                                []
                              |),
                              [
                                M.call_closure (|
                                  M.get_function (|
                                    "move_bytecode_verifier::type_safety::instantiate",
                                    []
                                  |),
                                  [ M.read (| M.read (| ty |) |); M.read (| subst |) ]
                                |)
                              ]
                            |)
                          ]
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "move_binary_format::file_format::SignatureToken::Struct",
                          0
                        |) in
                      let idx := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        Value.StructTuple
                          "move_binary_format::file_format::SignatureToken::Struct"
                          [ M.read (| M.read (| idx |) |) ]
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "move_binary_format::file_format::SignatureToken::StructInstantiation",
                          0
                        |) in
                      let struct_inst := M.alloc (| γ1_0 |) in
                      M.match_operator (|
                        M.alloc (| M.read (| M.read (| struct_inst |) |) |),
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let γ := M.read (| γ |) in
                              let γ1_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                              let γ1_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                              let idx := M.alloc (| γ1_0 |) in
                              let struct_type_args := M.alloc (| γ1_1 |) in
                              M.alloc (|
                                Value.StructTuple
                                  "move_binary_format::file_format::SignatureToken::StructInstantiation"
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.apply
                                          (Ty.path "alloc::boxed::Box")
                                          []
                                          [
                                            Ty.tuple
                                              [
                                                Ty.path
                                                  "move_binary_format::file_format::StructHandleIndex";
                                                Ty.apply
                                                  (Ty.path "alloc::vec::Vec")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_binary_format::file_format::SignatureToken";
                                                    Ty.path "alloc::alloc::Global"
                                                  ]
                                              ];
                                            Ty.path "alloc::alloc::Global"
                                          ],
                                        "new",
                                        []
                                      |),
                                      [
                                        Value.Tuple
                                          [
                                            M.read (| M.read (| idx |) |);
                                            M.call_closure (|
                                              M.get_trait_method (|
                                                "core::iter::traits::iterator::Iterator",
                                                Ty.apply
                                                  (Ty.path "core::iter::adapters::map::Map")
                                                  []
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::slice::iter::Iter")
                                                      []
                                                      [
                                                        Ty.path
                                                          "move_binary_format::file_format::SignatureToken"
                                                      ];
                                                    Ty.function
                                                      [
                                                        Ty.tuple
                                                          [
                                                            Ty.apply
                                                              (Ty.path "&")
                                                              []
                                                              [
                                                                Ty.path
                                                                  "move_binary_format::file_format::SignatureToken"
                                                              ]
                                                          ]
                                                      ]
                                                      (Ty.path
                                                        "move_binary_format::file_format::SignatureToken")
                                                  ],
                                                [],
                                                "collect",
                                                [
                                                  Ty.apply
                                                    (Ty.path "alloc::vec::Vec")
                                                    []
                                                    [
                                                      Ty.path
                                                        "move_binary_format::file_format::SignatureToken";
                                                      Ty.path "alloc::alloc::Global"
                                                    ]
                                                ]
                                              |),
                                              [
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::iter::traits::iterator::Iterator",
                                                    Ty.apply
                                                      (Ty.path "core::slice::iter::Iter")
                                                      []
                                                      [
                                                        Ty.path
                                                          "move_binary_format::file_format::SignatureToken"
                                                      ],
                                                    [],
                                                    "map",
                                                    [
                                                      Ty.path
                                                        "move_binary_format::file_format::SignatureToken";
                                                      Ty.function
                                                        [
                                                          Ty.tuple
                                                            [
                                                              Ty.apply
                                                                (Ty.path "&")
                                                                []
                                                                [
                                                                  Ty.path
                                                                    "move_binary_format::file_format::SignatureToken"
                                                                ]
                                                            ]
                                                        ]
                                                        (Ty.path
                                                          "move_binary_format::file_format::SignatureToken")
                                                    ]
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.apply
                                                          (Ty.path "slice")
                                                          []
                                                          [
                                                            Ty.path
                                                              "move_binary_format::file_format::SignatureToken"
                                                          ],
                                                        "iter",
                                                        []
                                                      |),
                                                      [
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::ops::deref::Deref",
                                                            Ty.apply
                                                              (Ty.path "alloc::vec::Vec")
                                                              []
                                                              [
                                                                Ty.path
                                                                  "move_binary_format::file_format::SignatureToken";
                                                                Ty.path "alloc::alloc::Global"
                                                              ],
                                                            [],
                                                            "deref",
                                                            []
                                                          |),
                                                          [ M.read (| struct_type_args |) ]
                                                        |)
                                                      ]
                                                    |);
                                                    M.closure
                                                      (fun γ =>
                                                        ltac:(M.monadic
                                                          match γ with
                                                          | [ α0 ] =>
                                                            ltac:(M.monadic
                                                              (M.match_operator (|
                                                                M.alloc (| α0 |),
                                                                [
                                                                  fun γ =>
                                                                    ltac:(M.monadic
                                                                      (let ty := M.copy (| γ |) in
                                                                      M.call_closure (|
                                                                        M.get_function (|
                                                                          "move_bytecode_verifier::type_safety::instantiate",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.read (| ty |);
                                                                          M.read (| subst |)
                                                                        ]
                                                                      |)))
                                                                ]
                                                              |)))
                                                          | _ =>
                                                            M.impossible "wrong number of arguments"
                                                          end))
                                                  ]
                                                |)
                                              ]
                                            |)
                                          ]
                                      ]
                                    |)
                                  ]
                              |)))
                        ]
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "move_binary_format::file_format::SignatureToken::Reference",
                          0
                        |) in
                      let ty := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        Value.StructTuple
                          "move_binary_format::file_format::SignatureToken::Reference"
                          [
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.apply
                                  (Ty.path "alloc::boxed::Box")
                                  []
                                  [
                                    Ty.path "move_binary_format::file_format::SignatureToken";
                                    Ty.path "alloc::alloc::Global"
                                  ],
                                "new",
                                []
                              |),
                              [
                                M.call_closure (|
                                  M.get_function (|
                                    "move_bytecode_verifier::type_safety::instantiate",
                                    []
                                  |),
                                  [ M.read (| M.read (| ty |) |); M.read (| subst |) ]
                                |)
                              ]
                            |)
                          ]
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "move_binary_format::file_format::SignatureToken::MutableReference",
                          0
                        |) in
                      let ty := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        Value.StructTuple
                          "move_binary_format::file_format::SignatureToken::MutableReference"
                          [
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.apply
                                  (Ty.path "alloc::boxed::Box")
                                  []
                                  [
                                    Ty.path "move_binary_format::file_format::SignatureToken";
                                    Ty.path "alloc::alloc::Global"
                                  ],
                                "new",
                                []
                              |),
                              [
                                M.call_closure (|
                                  M.get_function (|
                                    "move_bytecode_verifier::type_safety::instantiate",
                                    []
                                  |),
                                  [ M.read (| M.read (| ty |) |); M.read (| subst |) ]
                                |)
                              ]
                            |)
                          ]
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "move_binary_format::file_format::SignatureToken::TypeParameter",
                          0
                        |) in
                      let idx := M.alloc (| γ1_0 |) in
                      let~ _ :=
                        M.match_operator (|
                          M.alloc (| Value.Tuple [] |),
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                let _ :=
                                  M.is_constant_or_break_match (|
                                    M.read (| γ |),
                                    Value.Bool true
                                  |) in
                                let~ _ :=
                                  M.match_operator (|
                                    M.alloc (| Value.Tuple [] |),
                                    [
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let γ :=
                                            M.use
                                              (M.alloc (|
                                                UnOp.not (|
                                                  BinOp.lt (|
                                                    M.rust_cast (M.read (| M.read (| idx |) |)),
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path
                                                          "move_binary_format::file_format::Signature",
                                                        "len",
                                                        []
                                                      |),
                                                      [ M.read (| subst |) ]
                                                    |)
                                                  |)
                                                |)
                                              |)) in
                                          let _ :=
                                            M.is_constant_or_break_match (|
                                              M.read (| γ |),
                                              Value.Bool true
                                            |) in
                                          M.alloc (|
                                            M.never_to_any (|
                                              M.call_closure (|
                                                M.get_function (| "core::panicking::panic", [] |),
                                                [
                                                  M.read (|
                                                    Value.String
                                                      "assertion failed: (*idx as usize) < subst.len()"
                                                  |)
                                                ]
                                              |)
                                            |)
                                          |)));
                                      fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                    ]
                                  |) in
                                M.alloc (| Value.Tuple [] |)));
                            fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                          ]
                        |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::clone::Clone",
                            Ty.path "move_binary_format::file_format::SignatureToken",
                            [],
                            "clone",
                            []
                          |),
                          [
                            M.call_closure (|
                              M.get_trait_method (|
                                "core::ops::index::Index",
                                Ty.apply
                                  (Ty.path "alloc::vec::Vec")
                                  []
                                  [
                                    Ty.path "move_binary_format::file_format::SignatureToken";
                                    Ty.path "alloc::alloc::Global"
                                  ],
                                [ Ty.path "usize" ],
                                "index",
                                []
                              |),
                              [
                                M.SubPointer.get_struct_tuple_field (|
                                  M.read (| subst |),
                                  "move_binary_format::file_format::Signature",
                                  0
                                |);
                                M.rust_cast (M.read (| M.read (| idx |) |))
                              ]
                            |)
                          ]
                        |)
                      |)))
                ]
              |)
            |)))
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_instantiate :
    M.IsFunction "move_bytecode_verifier::type_safety::instantiate" instantiate.
  
  (*
  fn get_vector_element_type(
      vector_ref_ty: SignatureToken,
      mut_ref_only: bool,
  ) -> Option<SignatureToken> {
      use SignatureToken::*;
      match vector_ref_ty {
          Reference(referred_type) => {
              if mut_ref_only {
                  None
              } else if let ST::Vector(element_type) = *referred_type {
                  Some( *element_type)
              } else {
                  None
              }
          }
          MutableReference(referred_type) => {
              if let ST::Vector(element_type) = *referred_type {
                  Some( *element_type)
              } else {
                  None
              }
          }
          _ => None,
      }
  }
  *)
  Definition get_vector_element_type (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [], [ vector_ref_ty; mut_ref_only ] =>
      ltac:(M.monadic
        (let vector_ref_ty := M.alloc (| vector_ref_ty |) in
        let mut_ref_only := M.alloc (| mut_ref_only |) in
        M.read (|
          M.match_operator (|
            vector_ref_ty,
            [
              fun γ =>
                ltac:(M.monadic
                  (let γ0_0 :=
                    M.SubPointer.get_struct_tuple_field (|
                      γ,
                      "move_binary_format::file_format::SignatureToken::Reference",
                      0
                    |) in
                  let referred_type := M.copy (| γ0_0 |) in
                  M.match_operator (|
                    M.alloc (| Value.Tuple [] |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.use mut_ref_only in
                          let _ :=
                            M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                          M.alloc (| Value.StructTuple "core::option::Option::None" [] |)));
                      fun γ =>
                        ltac:(M.monadic
                          (M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ := M.read (| referred_type |) in
                                  let γ0_0 :=
                                    M.SubPointer.get_struct_tuple_field (|
                                      γ,
                                      "move_binary_format::file_format::SignatureToken::Vector",
                                      0
                                    |) in
                                  let element_type := M.copy (| γ0_0 |) in
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ M.read (| M.read (| element_type |) |) ]
                                  |)));
                              fun γ =>
                                ltac:(M.monadic
                                  (M.alloc (| Value.StructTuple "core::option::Option::None" [] |)))
                            ]
                          |)))
                    ]
                  |)));
              fun γ =>
                ltac:(M.monadic
                  (let γ0_0 :=
                    M.SubPointer.get_struct_tuple_field (|
                      γ,
                      "move_binary_format::file_format::SignatureToken::MutableReference",
                      0
                    |) in
                  let referred_type := M.copy (| γ0_0 |) in
                  M.match_operator (|
                    M.alloc (| Value.Tuple [] |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| referred_type |) in
                          let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "move_binary_format::file_format::SignatureToken::Vector",
                              0
                            |) in
                          let element_type := M.copy (| γ0_0 |) in
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ M.read (| M.read (| element_type |) |) ]
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (M.alloc (| Value.StructTuple "core::option::Option::None" [] |)))
                    ]
                  |)));
              fun γ =>
                ltac:(M.monadic (M.alloc (| Value.StructTuple "core::option::Option::None" [] |)))
            ]
          |)
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_get_vector_element_type :
    M.IsFunction
      "move_bytecode_verifier::type_safety::get_vector_element_type"
      get_vector_element_type.
End type_safety.
