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

Module reference_safety.
  (* StructRecord
    {
      name := "ReferenceSafetyAnalysis";
      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" ]);
          ("name_def_map",
            Ty.apply
              (Ty.path "&")
              []
              [
                Ty.apply
                  (Ty.path "std::collections::hash::map::HashMap")
                  []
                  [
                    Ty.path "move_binary_format::file_format::IdentifierIndex";
                    Ty.path "move_binary_format::file_format::FunctionDefinitionIndex";
                    Ty.path "std::hash::random::RandomState"
                  ]
              ]);
          ("stack",
            Ty.apply
              (Ty.path "move_abstract_stack::AbstractStack")
              []
              [ Ty.path "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue" ])
        ];
    } *)
  
  Module Impl_move_bytecode_verifier_reference_safety_ReferenceSafetyAnalysis.
    Definition Self : Ty.t :=
      Ty.path "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis".
    
    (*
        fn new(
            module: &'a CompiledModule,
            function_context: &'a FunctionContext<'a>,
            name_def_map: &'a HashMap<IdentifierIndex, FunctionDefinitionIndex>,
        ) -> Self {
            Self {
                module,
                function_context,
                name_def_map,
                stack: AbstractStack::new(),
            }
        }
    *)
    Definition new (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ module; function_context; name_def_map ] =>
        ltac:(M.monadic
          (let module := M.alloc (| module |) in
          let function_context := M.alloc (| function_context |) in
          let name_def_map := M.alloc (| name_def_map |) in
          Value.StructRecord
            "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis"
            [
              ("module", M.read (| module |));
              ("function_context", M.read (| function_context |));
              ("name_def_map", M.read (| name_def_map |));
              ("stack",
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.apply
                      (Ty.path "move_abstract_stack::AbstractStack")
                      []
                      [
                        Ty.path
                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                      ],
                    "new",
                    []
                  |),
                  []
                |))
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom AssociatedFunction_new : M.IsAssociatedFunction Self "new" new.
    
    (*
        fn push(&mut self, v: AbstractValue) -> PartialVMResult<()> {
            safe_unwrap_err!(self.stack.push(v));
            Ok(())
        }
    *)
    Definition push (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; v ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let v := M.alloc (| v |) in
          M.catch_return (|
            ltac:(M.monadic
              (M.read (|
                let~ _ :=
                  M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.apply
                            (Ty.path "move_abstract_stack::AbstractStack")
                            []
                            [
                              Ty.path
                                "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                            ],
                          "push",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| self |),
                            "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                            "stack"
                          |);
                          M.read (| v |)
                        ]
                      |)
                    |),
                    [
                      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/reference_safety/mod.rs:58 "
                                                          |)
                                                        ]
                                                    |);
                                                    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, v: AbstractValue, n: u64) -> PartialVMResult<()> {
            safe_unwrap_err!(self.stack.push_n(v, n));
            Ok(())
        }
    *)
    Definition push_n (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ self; v; n ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let v := M.alloc (| v |) 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_associated_function (|
                          Ty.apply
                            (Ty.path "move_abstract_stack::AbstractStack")
                            []
                            [
                              Ty.path
                                "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                            ],
                          "push_n",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| self |),
                            "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                            "stack"
                          |);
                          M.read (| v |);
                          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/reference_safety/mod.rs:63 "
                                                          |)
                                                        ]
                                                    |);
                                                    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.
  End Impl_move_bytecode_verifier_reference_safety_ReferenceSafetyAnalysis.
  
  (*
  pub(crate) fn verify<'a>(
      module: &'a CompiledModule,
      function_context: &FunctionContext,
      name_def_map: &'a HashMap<IdentifierIndex, FunctionDefinitionIndex>,
      meter: &mut (impl Meter + ?Sized),
  ) -> PartialVMResult<()> {
      let initial_state = AbstractState::new(function_context);
  
      let mut verifier = ReferenceSafetyAnalysis::new(module, function_context, name_def_map);
      verifier.analyze_function(initial_state, function_context, meter)
  }
  *)
  Definition verify (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [ impl_Meter__plus___Sized ], [ module; function_context; name_def_map; meter ] =>
      ltac:(M.monadic
        (let module := M.alloc (| module |) in
        let function_context := M.alloc (| function_context |) in
        let name_def_map := M.alloc (| name_def_map |) in
        let meter := M.alloc (| meter |) in
        M.read (|
          let~ initial_state :=
            M.alloc (|
              M.call_closure (|
                M.get_associated_function (|
                  Ty.path "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                  "new",
                  []
                |),
                [ M.read (| function_context |) ]
              |)
            |) in
          let~ verifier :=
            M.alloc (|
              M.call_closure (|
                M.get_associated_function (|
                  Ty.path "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                  "new",
                  []
                |),
                [ M.read (| module |); M.read (| function_context |); M.read (| name_def_map |) ]
              |)
            |) in
          M.alloc (|
            M.call_closure (|
              M.get_trait_method (|
                "move_bytecode_verifier::absint::AbstractInterpreter",
                Ty.path "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                [],
                "analyze_function",
                [ impl_Meter__plus___Sized ]
              |),
              [
                verifier;
                M.read (| initial_state |);
                M.read (| function_context |);
                M.read (| meter |)
              ]
            |)
          |)
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_verify : M.IsFunction "move_bytecode_verifier::reference_safety::verify" verify.
  
  (*
  fn call(
      verifier: &mut ReferenceSafetyAnalysis,
      state: &mut AbstractState,
      offset: CodeOffset,
      function_handle: &FunctionHandle,
      meter: &mut (impl Meter + ?Sized),
  ) -> PartialVMResult<()> {
      let parameters = verifier.module.signature_at(function_handle.parameters);
      let arguments = parameters
          .0
          .iter()
          .map(|_| verifier.stack.pop().unwrap())
          .rev()
          .collect();
  
      let acquired_resources = match verifier.name_def_map.get(&function_handle.name) {
          Some(idx) => {
              let func_def = verifier.module.function_def_at( *idx);
              let fh = verifier.module.function_handle_at(func_def.function);
              if function_handle == fh {
                  func_def.acquires_global_resources.iter().cloned().collect()
              } else {
                  BTreeSet::new()
              }
          }
          None => BTreeSet::new(),
      };
      let return_ = verifier.module.signature_at(function_handle.return_);
      let values = state.call(offset, arguments, &acquired_resources, return_, meter)?;
      for value in values {
          verifier.push(value)?
      }
      Ok(())
  }
  *)
  Definition call (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [ impl_Meter__plus___Sized ], [ verifier; state; offset; function_handle; meter ] =>
      ltac:(M.monadic
        (let verifier := M.alloc (| verifier |) in
        let state := M.alloc (| state |) in
        let offset := M.alloc (| offset |) in
        let function_handle := M.alloc (| function_handle |) in
        let meter := M.alloc (| meter |) 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::reference_safety::ReferenceSafetyAnalysis",
                          "module"
                        |)
                      |);
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| function_handle |),
                          "move_binary_format::file_format::FunctionHandle",
                          "parameters"
                        |)
                      |)
                    ]
                  |)
                |) in
              let~ arguments :=
                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::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_bytecode_verifier::reference_safety::abstract_state::AbstractValue")
                            ]
                        ],
                      [],
                      "collect",
                      [
                        Ty.apply
                          (Ty.path "alloc::vec::Vec")
                          []
                          [
                            Ty.path
                              "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                            Ty.path "alloc::alloc::Global"
                          ]
                      ]
                    |),
                    [
                      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_bytecode_verifier::reference_safety::abstract_state::AbstractValue")
                            ],
                          [],
                          "rev",
                          []
                        |),
                        [
                          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_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                Ty.function
                                  [
                                    Ty.tuple
                                      [
                                        Ty.apply
                                          (Ty.path "&")
                                          []
                                          [
                                            Ty.path
                                              "move_binary_format::file_format::SignatureToken"
                                          ]
                                      ]
                                  ]
                                  (Ty.path
                                    "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue")
                              ]
                            |),
                            [
                              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
                                      |)
                                    ]
                                  |)
                                ]
                              |);
                              M.closure
                                (fun γ =>
                                  ltac:(M.monadic
                                    match γ with
                                    | [ α0 ] =>
                                      ltac:(M.monadic
                                        (M.match_operator (|
                                          M.alloc (| α0 |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.apply
                                                      (Ty.path "core::result::Result")
                                                      []
                                                      [
                                                        Ty.path
                                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                                        Ty.path "move_abstract_stack::AbsStackError"
                                                      ],
                                                    "unwrap",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.apply
                                                          (Ty.path
                                                            "move_abstract_stack::AbstractStack")
                                                          []
                                                          [
                                                            Ty.path
                                                              "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                          ],
                                                        "pop",
                                                        []
                                                      |),
                                                      [
                                                        M.SubPointer.get_struct_record_field (|
                                                          M.read (| verifier |),
                                                          "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                          "stack"
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)))
                                          ]
                                        |)))
                                    | _ => M.impossible "wrong number of arguments"
                                    end))
                            ]
                          |)
                        ]
                      |)
                    ]
                  |)
                |) in
              let~ acquired_resources :=
                M.copy (|
                  M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.apply
                            (Ty.path "std::collections::hash::map::HashMap")
                            []
                            [
                              Ty.path "move_binary_format::file_format::IdentifierIndex";
                              Ty.path "move_binary_format::file_format::FunctionDefinitionIndex";
                              Ty.path "std::hash::random::RandomState"
                            ],
                          "get",
                          [ Ty.path "move_binary_format::file_format::IdentifierIndex" ]
                        |),
                        [
                          M.read (|
                            M.SubPointer.get_struct_record_field (|
                              M.read (| verifier |),
                              "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                              "name_def_map"
                            |)
                          |);
                          M.SubPointer.get_struct_record_field (|
                            M.read (| function_handle |),
                            "move_binary_format::file_format::FunctionHandle",
                            "name"
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::option::Option::Some",
                              0
                            |) in
                          let idx := M.copy (| γ0_0 |) in
                          let~ func_def :=
                            M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "move_binary_format::file_format::CompiledModule",
                                  "function_def_at",
                                  []
                                |),
                                [
                                  M.read (|
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                      "module"
                                    |)
                                  |);
                                  M.read (| M.read (| idx |) |)
                                ]
                              |)
                            |) in
                          let~ fh :=
                            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::reference_safety::ReferenceSafetyAnalysis",
                                      "module"
                                    |)
                                  |);
                                  M.read (|
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| func_def |),
                                      "move_binary_format::file_format::FunctionDefinition",
                                      "function"
                                    |)
                                  |)
                                ]
                              |)
                            |) in
                          M.match_operator (|
                            M.alloc (| Value.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::FunctionHandle"
                                              ],
                                            [
                                              Ty.apply
                                                (Ty.path "&")
                                                []
                                                [
                                                  Ty.path
                                                    "move_binary_format::file_format::FunctionHandle"
                                                ]
                                            ],
                                            "eq",
                                            []
                                          |),
                                          [ function_handle; fh ]
                                        |)
                                      |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  M.alloc (|
                                    M.call_closure (|
                                      M.get_trait_method (|
                                        "core::iter::traits::iterator::Iterator",
                                        Ty.apply
                                          (Ty.path "core::iter::adapters::cloned::Cloned")
                                          []
                                          [
                                            Ty.apply
                                              (Ty.path "core::slice::iter::Iter")
                                              []
                                              [
                                                Ty.path
                                                  "move_binary_format::file_format::StructDefinitionIndex"
                                              ]
                                          ],
                                        [],
                                        "collect",
                                        [
                                          Ty.apply
                                            (Ty.path "alloc::collections::btree::set::BTreeSet")
                                            []
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::StructDefinitionIndex";
                                              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::StructDefinitionIndex"
                                              ],
                                            [],
                                            "cloned",
                                            [
                                              Ty.path
                                                "move_binary_format::file_format::StructDefinitionIndex"
                                            ]
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.apply
                                                  (Ty.path "slice")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_binary_format::file_format::StructDefinitionIndex"
                                                  ],
                                                "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::StructDefinitionIndex";
                                                        Ty.path "alloc::alloc::Global"
                                                      ],
                                                    [],
                                                    "deref",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_struct_record_field (|
                                                      M.read (| func_def |),
                                                      "move_binary_format::file_format::FunctionDefinition",
                                                      "acquires_global_resources"
                                                    |)
                                                  ]
                                                |)
                                              ]
                                            |)
                                          ]
                                        |)
                                      ]
                                    |)
                                  |)));
                              fun γ =>
                                ltac:(M.monadic
                                  (M.alloc (|
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.apply
                                          (Ty.path "alloc::collections::btree::set::BTreeSet")
                                          []
                                          [
                                            Ty.path
                                              "move_binary_format::file_format::StructDefinitionIndex";
                                            Ty.path "alloc::alloc::Global"
                                          ],
                                        "new",
                                        []
                                      |),
                                      []
                                    |)
                                  |)))
                            ]
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let _ := M.is_struct_tuple (| γ, "core::option::Option::None" |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.apply
                                  (Ty.path "alloc::collections::btree::set::BTreeSet")
                                  []
                                  [
                                    Ty.path
                                      "move_binary_format::file_format::StructDefinitionIndex";
                                    Ty.path "alloc::alloc::Global"
                                  ],
                                "new",
                                []
                              |),
                              []
                            |)
                          |)))
                    ]
                  |)
                |) in
              let~ return_ :=
                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::reference_safety::ReferenceSafetyAnalysis",
                          "module"
                        |)
                      |);
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| function_handle |),
                          "move_binary_format::file_format::FunctionHandle",
                          "return_"
                        |)
                      |)
                    ]
                  |)
                |) in
              let~ values :=
                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.apply
                                (Ty.path "alloc::vec::Vec")
                                []
                                [
                                  Ty.path
                                    "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                  Ty.path "alloc::alloc::Global"
                                ];
                              Ty.path "move_binary_format::errors::PartialVMError"
                            ],
                          [],
                          "branch",
                          []
                        |),
                        [
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path
                                "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                              "call",
                              [ impl_Meter__plus___Sized ]
                            |),
                            [
                              M.read (| state |);
                              M.read (| offset |);
                              M.read (| arguments |);
                              acquired_resources;
                              M.read (| return_ |);
                              M.read (| meter |)
                            ]
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::ops::control_flow::ControlFlow::Break",
                              0
                            |) in
                          let residual := M.copy (| γ0_0 |) in
                          M.alloc (|
                            M.never_to_any (|
                              M.read (|
                                M.return_ (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::ops::try_trait::FromResidual",
                                      Ty.apply
                                        (Ty.path "core::result::Result")
                                        []
                                        [
                                          Ty.tuple [];
                                          Ty.path "move_binary_format::errors::PartialVMError"
                                        ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::result::Result")
                                          []
                                          [
                                            Ty.path "core::convert::Infallible";
                                            Ty.path "move_binary_format::errors::PartialVMError"
                                          ]
                                      ],
                                      "from_residual",
                                      []
                                    |),
                                    [ M.read (| residual |) ]
                                  |)
                                |)
                              |)
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::ops::control_flow::ControlFlow::Continue",
                              0
                            |) in
                          let val := M.copy (| γ0_0 |) in
                          val))
                    ]
                  |)
                |) in
              let~ _ :=
                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_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                              Ty.path "alloc::alloc::Global"
                            ],
                          [],
                          "into_iter",
                          []
                        |),
                        [ M.read (| values |) ]
                      |)
                    |),
                    [
                      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_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                            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 value := 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::reference_safety::ReferenceSafetyAnalysis",
                                                    "push",
                                                    []
                                                  |),
                                                  [ M.read (| verifier |); M.read (| value |) ]
                                                |)
                                              ]
                                            |)
                                          |),
                                          [
                                            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::reference_safety::call" call.
  
  (*
  fn num_fields(struct_def: &StructDefinition) -> usize {
      match &struct_def.field_information {
          StructFieldInformation::Native => 0,
          StructFieldInformation::Declared(fields) => fields.len(),
      }
  }
  *)
  Definition num_fields (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [], [ struct_def ] =>
      ltac:(M.monadic
        (let struct_def := M.alloc (| struct_def |) 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.Integer IntegerKind.Usize 0 |)));
              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_associated_function (|
                        Ty.apply
                          (Ty.path "alloc::vec::Vec")
                          []
                          [
                            Ty.path "move_binary_format::file_format::FieldDefinition";
                            Ty.path "alloc::alloc::Global"
                          ],
                        "len",
                        []
                      |),
                      [ M.read (| fields |) ]
                    |)
                  |)))
            ]
          |)
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_num_fields :
    M.IsFunction "move_bytecode_verifier::reference_safety::num_fields" num_fields.
  
  (*
  fn pack(
      verifier: &mut ReferenceSafetyAnalysis,
      struct_def: &StructDefinition,
  ) -> PartialVMResult<()> {
      for _ in 0..num_fields(struct_def) {
          safe_assert!(safe_unwrap_err!(verifier.stack.pop()).is_value())
      }
      // TODO maybe call state.value_for
      verifier.push(AbstractValue::NonReference)?;
      Ok(())
  }
  *)
  Definition pack (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [], [ verifier; struct_def ] =>
      ltac:(M.monadic
        (let verifier := M.alloc (| verifier |) in
        let struct_def := M.alloc (| struct_def |) 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 "core::ops::range::Range") [] [ Ty.path "usize" ],
                          [],
                          "into_iter",
                          []
                        |),
                        [
                          Value.StructRecord
                            "core::ops::range::Range"
                            [
                              ("start", Value.Integer IntegerKind.Usize 0);
                              ("end_",
                                M.call_closure (|
                                  M.get_function (|
                                    "move_bytecode_verifier::reference_safety::num_fields",
                                    []
                                  |),
                                  [ M.read (| struct_def |) ]
                                |))
                            ]
                        ]
                      |)
                    |),
                    [
                      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::ops::range::Range")
                                          []
                                          [ Ty.path "usize" ],
                                        [],
                                        "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
                                        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_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                                            "is_value",
                                                            []
                                                          |),
                                                          [
                                                            M.match_operator (|
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "move_abstract_stack::AbstractStack")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                                      ],
                                                                    "pop",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_struct_record_field (|
                                                                      M.read (| verifier |),
                                                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                                      "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/reference_safety/mod.rs:127 "
                                                                                                    |)
                                                                                                  ]
                                                                                              |);
                                                                                              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.is_constant_or_break_match (|
                                                    M.read (| γ |),
                                                    Value.Bool true
                                                  |) 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",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                M.read (|
                                                                                  Value.String
                                                                                    "crates/move-bytecode-verifier/src/reference_safety/mod.rs:127 (assert)"
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          M.alloc (|
                                                                            M.call_closure (|
                                                                              M.get_associated_function (|
                                                                                Ty.path
                                                                                  "core::fmt::rt::Argument",
                                                                                "none",
                                                                                []
                                                                              |),
                                                                              []
                                                                            |)
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |) 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 |) ]
                                                              |)
                                                            |)
                                                          |)
                                                        |)))
                                                  ]
                                                |)));
                                            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::reference_safety::ReferenceSafetyAnalysis",
                            "push",
                            []
                          |),
                          [
                            M.read (| verifier |);
                            Value.StructTuple
                              "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue::NonReference"
                              []
                          ]
                        |)
                      ]
                    |)
                  |),
                  [
                    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::reference_safety::pack" pack.
  
  (*
  fn unpack(
      verifier: &mut ReferenceSafetyAnalysis,
      struct_def: &StructDefinition,
  ) -> PartialVMResult<()> {
      safe_assert!(safe_unwrap_err!(verifier.stack.pop()).is_value());
      // TODO maybe call state.value_for
      verifier.push_n(AbstractValue::NonReference, num_fields(struct_def) as u64)?;
      Ok(())
  }
  *)
  Definition unpack (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [], [ verifier; struct_def ] =>
      ltac:(M.monadic
        (let verifier := M.alloc (| verifier |) in
        let struct_def := M.alloc (| struct_def |) 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 (|
                              UnOp.not (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                    "is_value",
                                    []
                                  |),
                                  [
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.apply
                                              (Ty.path "move_abstract_stack::AbstractStack")
                                              []
                                              [
                                                Ty.path
                                                  "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                              ],
                                            "pop",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_struct_record_field (|
                                              M.read (| verifier |),
                                              "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                              "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/reference_safety/mod.rs:138 "
                                                                            |)
                                                                          ]
                                                                      |);
                                                                      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.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) 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",
                                                  []
                                                |),
                                                [
                                                  M.alloc (|
                                                    Value.Array
                                                      [
                                                        M.read (|
                                                          Value.String
                                                            "crates/move-bytecode-verifier/src/reference_safety/mod.rs:138 (assert)"
                                                        |)
                                                      ]
                                                  |);
                                                  M.alloc (|
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::rt::Argument",
                                                        "none",
                                                        []
                                                      |),
                                                      []
                                                    |)
                                                  |)
                                                ]
                                              |)
                                            ]
                                          |)
                                        |) 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 |) ]
                                      |)
                                    |)
                                  |)
                                |)))
                          ]
                        |)));
                    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::reference_safety::ReferenceSafetyAnalysis",
                            "push_n",
                            []
                          |),
                          [
                            M.read (| verifier |);
                            Value.StructTuple
                              "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue::NonReference"
                              [];
                            M.rust_cast
                              (M.call_closure (|
                                M.get_function (|
                                  "move_bytecode_verifier::reference_safety::num_fields",
                                  []
                                |),
                                [ M.read (| struct_def |) ]
                              |))
                          ]
                        |)
                      ]
                    |)
                  |),
                  [
                    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_unpack : M.IsFunction "move_bytecode_verifier::reference_safety::unpack" unpack.
  
  (*
  fn vec_element_type(
      verifier: &mut ReferenceSafetyAnalysis,
      idx: SignatureIndex,
  ) -> PartialVMResult<SignatureToken> {
      match verifier.module.signature_at(idx).0.first() {
          Some(ty) => Ok(ty.clone()),
          None => Err(PartialVMError::new(
              StatusCode::VERIFIER_INVARIANT_VIOLATION,
          )),
      }
  }
  *)
  Definition vec_element_type (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [], [ verifier; idx ] =>
      ltac:(M.monadic
        (let verifier := M.alloc (| verifier |) in
        let idx := M.alloc (| idx |) in
        M.read (|
          M.match_operator (|
            M.alloc (|
              M.call_closure (|
                M.get_associated_function (|
                  Ty.apply
                    (Ty.path "slice")
                    []
                    [ Ty.path "move_binary_format::file_format::SignatureToken" ],
                  "first",
                  []
                |),
                [
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::deref::Deref",
                      Ty.apply
                        (Ty.path "alloc::vec::Vec")
                        []
                        [
                          Ty.path "move_binary_format::file_format::SignatureToken";
                          Ty.path "alloc::alloc::Global"
                        ],
                      [],
                      "deref",
                      []
                    |),
                    [
                      M.SubPointer.get_struct_tuple_field (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "move_binary_format::file_format::CompiledModule",
                            "signature_at",
                            []
                          |),
                          [
                            M.read (|
                              M.SubPointer.get_struct_record_field (|
                                M.read (| verifier |),
                                "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                "module"
                              |)
                            |);
                            M.read (| idx |)
                          ]
                        |),
                        "move_binary_format::file_format::Signature",
                        0
                      |)
                    ]
                  |)
                ]
              |)
            |),
            [
              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.alloc (|
                    Value.StructTuple
                      "core::result::Result::Ok"
                      [
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::clone::Clone",
                            Ty.path "move_binary_format::file_format::SignatureToken",
                            [],
                            "clone",
                            []
                          |),
                          [ M.read (| ty |) ]
                        |)
                      ]
                  |)));
              fun γ =>
                ltac:(M.monadic
                  (let _ := M.is_struct_tuple (| γ, "core::option::Option::None" |) in
                  M.alloc (|
                    Value.StructTuple
                      "core::result::Result::Err"
                      [
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "move_binary_format::errors::PartialVMError",
                            "new",
                            []
                          |),
                          [
                            Value.StructTuple
                              "move_core_types::vm_status::StatusCode::VERIFIER_INVARIANT_VIOLATION"
                              []
                          ]
                        |)
                      ]
                  |)))
            ]
          |)
        |)))
    | _, _, _ => M.impossible "wrong number of arguments"
    end.
  
  Axiom Function_vec_element_type :
    M.IsFunction "move_bytecode_verifier::reference_safety::vec_element_type" vec_element_type.
  
  (*
  fn execute_inner(
      verifier: &mut ReferenceSafetyAnalysis,
      state: &mut AbstractState,
      bytecode: &Bytecode,
      offset: CodeOffset,
      meter: &mut (impl Meter + ?Sized),
  ) -> PartialVMResult<()> {
      meter.add(Scope::Function, STEP_BASE_COST)?;
      meter.add_items(Scope::Function, STEP_PER_LOCAL_COST, state.local_count())?;
      meter.add_items(
          Scope::Function,
          STEP_PER_GRAPH_ITEM_COST,
          state.graph_size(),
      )?;
  
      match bytecode {
          Bytecode::Pop => state.release_value(safe_unwrap_err!(verifier.stack.pop())),
  
          Bytecode::CopyLoc(local) => {
              let value = state.copy_loc(offset, *local)?;
              verifier.push(value)?
          }
          Bytecode::MoveLoc(local) => {
              let value = state.move_loc(offset, *local)?;
              verifier.push(value)?
          }
          Bytecode::StLoc(local) => {
              state.st_loc(offset, *local, safe_unwrap_err!(verifier.stack.pop()))?
          }
  
          Bytecode::FreezeRef => {
              let id = safe_unwrap!(safe_unwrap_err!(verifier.stack.pop()).ref_id());
              let frozen = state.freeze_ref(offset, id)?;
              verifier.push(frozen)?
          }
          Bytecode::Eq | Bytecode::Neq => {
              let v1 = safe_unwrap_err!(verifier.stack.pop());
              let v2 = safe_unwrap_err!(verifier.stack.pop());
              let value = state.comparison(offset, v1, v2)?;
              verifier.push(value)?
          }
          Bytecode::ReadRef => {
              let id = safe_unwrap!(safe_unwrap_err!(verifier.stack.pop()).ref_id());
              let value = state.read_ref(offset, id)?;
              verifier.push(value)?
          }
          Bytecode::WriteRef => {
              let id = safe_unwrap!(safe_unwrap_err!(verifier.stack.pop()).ref_id());
              let val_operand = safe_unwrap_err!(verifier.stack.pop());
              safe_assert!(val_operand.is_value());
              state.write_ref(offset, id)?
          }
  
          Bytecode::MutBorrowLoc(local) => {
              let value = state.borrow_loc(offset, true, *local)?;
              verifier.push(value)?
          }
          Bytecode::ImmBorrowLoc(local) => {
              let value = state.borrow_loc(offset, false, *local)?;
              verifier.push(value)?
          }
          Bytecode::MutBorrowField(field_handle_index) => {
              let id = safe_unwrap!(safe_unwrap_err!(verifier.stack.pop()).ref_id());
              let value = state.borrow_field(offset, true, id, *field_handle_index)?;
              verifier.push(value)?
          }
          Bytecode::MutBorrowFieldGeneric(field_inst_index) => {
              let field_inst = verifier.module.field_instantiation_at( *field_inst_index);
              let id = safe_unwrap!(safe_unwrap_err!(verifier.stack.pop()).ref_id());
              let value = state.borrow_field(offset, true, id, field_inst.handle)?;
              verifier.push(value)?
          }
          Bytecode::ImmBorrowField(field_handle_index) => {
              let id = safe_unwrap!(safe_unwrap_err!(verifier.stack.pop()).ref_id());
              let value = state.borrow_field(offset, false, id, *field_handle_index)?;
              verifier.push(value)?
          }
          Bytecode::ImmBorrowFieldGeneric(field_inst_index) => {
              let field_inst = verifier.module.field_instantiation_at( *field_inst_index);
              let id = safe_unwrap!(safe_unwrap_err!(verifier.stack.pop()).ref_id());
              let value = state.borrow_field(offset, false, id, field_inst.handle)?;
              verifier.push(value)?
          }
  
          Bytecode::MutBorrowGlobalDeprecated(idx) => {
              safe_assert!(safe_unwrap_err!(verifier.stack.pop()).is_value());
              let value = state.borrow_global(offset, true, *idx)?;
              verifier.push(value)?
          }
          Bytecode::MutBorrowGlobalGenericDeprecated(idx) => {
              safe_assert!(safe_unwrap_err!(verifier.stack.pop()).is_value());
              let struct_inst = verifier.module.struct_instantiation_at( *idx);
              let value = state.borrow_global(offset, true, struct_inst.def)?;
              verifier.push(value)?
          }
          Bytecode::ImmBorrowGlobalDeprecated(idx) => {
              safe_assert!(safe_unwrap_err!(verifier.stack.pop()).is_value());
              let value = state.borrow_global(offset, false, *idx)?;
              verifier.push(value)?
          }
          Bytecode::ImmBorrowGlobalGenericDeprecated(idx) => {
              safe_assert!(safe_unwrap_err!(verifier.stack.pop()).is_value());
              let struct_inst = verifier.module.struct_instantiation_at( *idx);
              let value = state.borrow_global(offset, false, struct_inst.def)?;
              verifier.push(value)?
          }
          Bytecode::MoveFromDeprecated(idx) => {
              safe_assert!(safe_unwrap_err!(verifier.stack.pop()).is_value());
              let value = state.move_from(offset, *idx)?;
              verifier.push(value)?
          }
          Bytecode::MoveFromGenericDeprecated(idx) => {
              safe_assert!(safe_unwrap_err!(verifier.stack.pop()).is_value());
              let struct_inst = verifier.module.struct_instantiation_at( *idx);
              let value = state.move_from(offset, struct_inst.def)?;
              verifier.push(value)?
          }
  
          Bytecode::Call(idx) => {
              let function_handle = verifier.module.function_handle_at( *idx);
              call(verifier, state, offset, function_handle, meter)?
          }
          Bytecode::CallGeneric(idx) => {
              let func_inst = verifier.module.function_instantiation_at( *idx);
              let function_handle = verifier.module.function_handle_at(func_inst.handle);
              call(verifier, state, offset, function_handle, meter)?
          }
  
          Bytecode::Ret => {
              let mut return_values = vec![];
              for _ in 0..verifier.function_context.return_().len() {
                  return_values.push(safe_unwrap_err!(verifier.stack.pop()));
              }
              return_values.reverse();
  
              state.ret(offset, return_values)?
          }
  
          Bytecode::Branch(_)
          | Bytecode::Nop
          | Bytecode::CastU8
          | Bytecode::CastU16
          | Bytecode::CastU32
          | Bytecode::CastU64
          | Bytecode::CastU128
          | Bytecode::CastU256
          | Bytecode::Not
          | Bytecode::ExistsDeprecated(_)
          | Bytecode::ExistsGenericDeprecated(_) => (),
  
          Bytecode::BrTrue(_) | Bytecode::BrFalse(_) | Bytecode::Abort => {
              safe_assert!(safe_unwrap_err!(verifier.stack.pop()).is_value());
          }
          Bytecode::MoveToDeprecated(_) | Bytecode::MoveToGenericDeprecated(_) => {
              // resource value
              safe_assert!(safe_unwrap_err!(verifier.stack.pop()).is_value());
              // signer reference
              state.release_value(safe_unwrap_err!(verifier.stack.pop()));
          }
  
          Bytecode::LdTrue | Bytecode::LdFalse => {
              verifier.push(state.value_for(&SignatureToken::Bool))?
          }
          Bytecode::LdU8(_) => verifier.push(state.value_for(&SignatureToken::U8))?,
          Bytecode::LdU16(_) => verifier.push(state.value_for(&SignatureToken::U16))?,
          Bytecode::LdU32(_) => verifier.push(state.value_for(&SignatureToken::U32))?,
          Bytecode::LdU64(_) => verifier.push(state.value_for(&SignatureToken::U64))?,
          Bytecode::LdU128(_) => verifier.push(state.value_for(&SignatureToken::U128))?,
          Bytecode::LdU256(_) => verifier.push(state.value_for(&SignatureToken::U256))?,
          Bytecode::LdConst(idx) => {
              let signature = &verifier.module.constant_at( *idx).type_;
              verifier.push(state.value_for(signature))?
          }
  
          Bytecode::Add
          | Bytecode::Sub
          | Bytecode::Mul
          | Bytecode::Mod
          | Bytecode::Div
          | Bytecode::BitOr
          | Bytecode::BitAnd
          | Bytecode::Xor
          | Bytecode::Shl
          | Bytecode::Shr
          | Bytecode::Or
          | Bytecode::And
          | Bytecode::Lt
          | Bytecode::Gt
          | Bytecode::Le
          | Bytecode::Ge => {
              safe_assert!(safe_unwrap_err!(verifier.stack.pop()).is_value());
              safe_assert!(safe_unwrap_err!(verifier.stack.pop()).is_value());
              // TODO maybe call state.value_for
              verifier.push(AbstractValue::NonReference)?
          }
  
          Bytecode::Pack(idx) => {
              let struct_def = verifier.module.struct_def_at( *idx);
              pack(verifier, struct_def)?
          }
          Bytecode::PackGeneric(idx) => {
              let struct_inst = verifier.module.struct_instantiation_at( *idx);
              let struct_def = verifier.module.struct_def_at(struct_inst.def);
              pack(verifier, struct_def)?
          }
          Bytecode::Unpack(idx) => {
              let struct_def = verifier.module.struct_def_at( *idx);
              unpack(verifier, struct_def)?
          }
          Bytecode::UnpackGeneric(idx) => {
              let struct_inst = verifier.module.struct_instantiation_at( *idx);
              let struct_def = verifier.module.struct_def_at(struct_inst.def);
              unpack(verifier, struct_def)?
          }
  
          Bytecode::VecPack(idx, num) => {
              if let Some(num_to_pop) = NonZeroU64::new( *num) {
                  let result = verifier.stack.pop_eq_n(num_to_pop);
                  let abs_value = safe_unwrap_err!(result);
                  safe_assert!(abs_value.is_value());
              }
  
              let element_type = vec_element_type(verifier, *idx)?;
              verifier.push(state.value_for(&SignatureToken::Vector(Box::new(element_type))))?
          }
  
          Bytecode::VecLen(_) => {
              let vec_ref = safe_unwrap_err!(verifier.stack.pop());
              state.vector_op(offset, vec_ref, false)?;
              verifier.push(state.value_for(&SignatureToken::U64))?
          }
  
          Bytecode::VecImmBorrow(_) => {
              safe_assert!(safe_unwrap_err!(verifier.stack.pop()).is_value());
              let vec_ref = safe_unwrap_err!(verifier.stack.pop());
              let elem_ref = state.vector_element_borrow(offset, vec_ref, false)?;
              verifier.push(elem_ref)?
          }
          Bytecode::VecMutBorrow(_) => {
              safe_assert!(safe_unwrap_err!(verifier.stack.pop()).is_value());
              let vec_ref = safe_unwrap_err!(verifier.stack.pop());
              let elem_ref = state.vector_element_borrow(offset, vec_ref, true)?;
              verifier.push(elem_ref)?
          }
  
          Bytecode::VecPushBack(_) => {
              safe_assert!(safe_unwrap_err!(verifier.stack.pop()).is_value());
              let vec_ref = safe_unwrap_err!(verifier.stack.pop());
              state.vector_op(offset, vec_ref, true)?;
          }
  
          Bytecode::VecPopBack(idx) => {
              let vec_ref = safe_unwrap_err!(verifier.stack.pop());
              state.vector_op(offset, vec_ref, true)?;
  
              let element_type = vec_element_type(verifier, *idx)?;
              verifier.push(state.value_for(&element_type))?
          }
  
          Bytecode::VecUnpack(idx, num) => {
              safe_assert!(safe_unwrap_err!(verifier.stack.pop()).is_value());
  
              let element_type = vec_element_type(verifier, *idx)?;
              verifier.push_n(state.value_for(&element_type), *num)?
          }
  
          Bytecode::VecSwap(_) => {
              safe_assert!(safe_unwrap_err!(verifier.stack.pop()).is_value());
              safe_assert!(safe_unwrap_err!(verifier.stack.pop()).is_value());
              let vec_ref = safe_unwrap_err!(verifier.stack.pop());
              state.vector_op(offset, vec_ref, true)?;
          }
      };
      Ok(())
  }
  *)
  Definition execute_inner (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
    match ε, τ, α with
    | [], [ impl_Meter__plus___Sized ], [ verifier; state; bytecode; offset; meter ] =>
      ltac:(M.monadic
        (let verifier := M.alloc (| verifier |) in
        let state := M.alloc (| state |) 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 (|
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "core::ops::try_trait::Try",
                        Ty.apply
                          (Ty.path "core::result::Result")
                          []
                          [ Ty.tuple []; Ty.path "move_binary_format::errors::PartialVMError" ],
                        [],
                        "branch",
                        []
                      |),
                      [
                        M.call_closure (|
                          M.get_trait_method (|
                            "move_bytecode_verifier_meter::Meter",
                            impl_Meter__plus___Sized,
                            [],
                            "add",
                            []
                          |),
                          [
                            M.read (| meter |);
                            Value.StructTuple "move_bytecode_verifier_meter::Scope::Function" [];
                            M.read (|
                              M.get_constant (|
                                "move_bytecode_verifier::reference_safety::abstract_state::STEP_BASE_COST"
                              |)
                            |)
                          ]
                        |)
                      ]
                    |)
                  |),
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ0_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "core::ops::control_flow::ControlFlow::Break",
                            0
                          |) in
                        let residual := M.copy (| γ0_0 |) in
                        M.alloc (|
                          M.never_to_any (|
                            M.read (|
                              M.return_ (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::ops::try_trait::FromResidual",
                                    Ty.apply
                                      (Ty.path "core::result::Result")
                                      []
                                      [
                                        Ty.tuple [];
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [
                                      Ty.apply
                                        (Ty.path "core::result::Result")
                                        []
                                        [
                                          Ty.path "core::convert::Infallible";
                                          Ty.path "move_binary_format::errors::PartialVMError"
                                        ]
                                    ],
                                    "from_residual",
                                    []
                                  |),
                                  [ M.read (| residual |) ]
                                |)
                              |)
                            |)
                          |)
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ0_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "core::ops::control_flow::ControlFlow::Continue",
                            0
                          |) in
                        let val := M.copy (| γ0_0 |) in
                        val))
                  ]
                |) in
              let~ _ :=
                M.match_operator (|
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "core::ops::try_trait::Try",
                        Ty.apply
                          (Ty.path "core::result::Result")
                          []
                          [ Ty.tuple []; Ty.path "move_binary_format::errors::PartialVMError" ],
                        [],
                        "branch",
                        []
                      |),
                      [
                        M.call_closure (|
                          M.get_trait_method (|
                            "move_bytecode_verifier_meter::Meter",
                            impl_Meter__plus___Sized,
                            [],
                            "add_items",
                            []
                          |),
                          [
                            M.read (| meter |);
                            Value.StructTuple "move_bytecode_verifier_meter::Scope::Function" [];
                            M.read (|
                              M.get_constant (|
                                "move_bytecode_verifier::reference_safety::abstract_state::STEP_PER_LOCAL_COST"
                              |)
                            |);
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path
                                  "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                "local_count",
                                []
                              |),
                              [ M.read (| state |) ]
                            |)
                          ]
                        |)
                      ]
                    |)
                  |),
                  [
                    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_trait_method (|
                        "core::ops::try_trait::Try",
                        Ty.apply
                          (Ty.path "core::result::Result")
                          []
                          [ Ty.tuple []; Ty.path "move_binary_format::errors::PartialVMError" ],
                        [],
                        "branch",
                        []
                      |),
                      [
                        M.call_closure (|
                          M.get_trait_method (|
                            "move_bytecode_verifier_meter::Meter",
                            impl_Meter__plus___Sized,
                            [],
                            "add_items",
                            []
                          |),
                          [
                            M.read (| meter |);
                            Value.StructTuple "move_bytecode_verifier_meter::Scope::Function" [];
                            M.read (|
                              M.get_constant (|
                                "move_bytecode_verifier::reference_safety::abstract_state::STEP_PER_GRAPH_ITEM_COST"
                              |)
                            |);
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path
                                  "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                "graph_size",
                                []
                              |),
                              [ M.read (| state |) ]
                            |)
                          ]
                        |)
                      ]
                    |)
                  |),
                  [
                    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 (|
                  bytecode,
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (|
                            γ,
                            "move_binary_format::file_format::Bytecode::Pop"
                          |) in
                        M.alloc (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path
                                "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                              "release_value",
                              []
                            |),
                            [
                              M.read (| state |);
                              M.read (|
                                M.match_operator (|
                                  M.alloc (|
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.apply
                                          (Ty.path "move_abstract_stack::AbstractStack")
                                          []
                                          [
                                            Ty.path
                                              "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                          ],
                                        "pop",
                                        []
                                      |),
                                      [
                                        M.SubPointer.get_struct_record_field (|
                                          M.read (| verifier |),
                                          "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                          "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/reference_safety/mod.rs:172 "
                                                                        |)
                                                                      ]
                                                                  |);
                                                                  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 |) ]
                                                      |)
                                                    |)
                                                  |)
                                                |)))
                                          ]
                                        |)))
                                  ]
                                |)
                              |)
                            ]
                          |)
                        |)));
                    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 local := M.alloc (| γ1_0 |) in
                        let~ value :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::ops::try_trait::Try",
                                    Ty.apply
                                      (Ty.path "core::result::Result")
                                      []
                                      [
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [],
                                    "branch",
                                    []
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "copy_loc",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        M.read (| offset |);
                                        M.read (| M.read (| local |) |)
                                      ]
                                    |)
                                  ]
                                |)
                              |),
                              [
                                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_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| value |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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 local := M.alloc (| γ1_0 |) in
                        let~ value :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::ops::try_trait::Try",
                                    Ty.apply
                                      (Ty.path "core::result::Result")
                                      []
                                      [
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [],
                                    "branch",
                                    []
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "move_loc",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        M.read (| offset |);
                                        M.read (| M.read (| local |) |)
                                      ]
                                    |)
                                  ]
                                |)
                              |),
                              [
                                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_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| value |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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::StLoc",
                            0
                          |) in
                        let local := 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_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                    "st_loc",
                                    []
                                  |),
                                  [
                                    M.read (| state |);
                                    M.read (| offset |);
                                    M.read (| M.read (| local |) |);
                                    M.read (|
                                      M.match_operator (|
                                        M.alloc (|
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.apply
                                                (Ty.path "move_abstract_stack::AbstractStack")
                                                []
                                                [
                                                  Ty.path
                                                    "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                ],
                                              "pop",
                                              []
                                            |),
                                            [
                                              M.SubPointer.get_struct_record_field (|
                                                M.read (| verifier |),
                                                "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                "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/reference_safety/mod.rs:183 "
                                                                              |)
                                                                            ]
                                                                        |);
                                                                        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 |) ]
                                                            |)
                                                          |)
                                                        |)
                                                      |)))
                                                ]
                                              |)))
                                        ]
                                      |)
                                    |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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::FreezeRef"
                          |) in
                        let~ id :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                    "ref_id",
                                    []
                                  |),
                                  [
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.apply
                                              (Ty.path "move_abstract_stack::AbstractStack")
                                              []
                                              [
                                                Ty.path
                                                  "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                              ],
                                            "pop",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_struct_record_field (|
                                              M.read (| verifier |),
                                              "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                              "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/reference_safety/mod.rs:187 "
                                                                            |)
                                                                          ]
                                                                      |);
                                                                      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 |) ]
                                                          |)
                                                        |)
                                                      |)
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::option::Option::Some",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (| γ, "core::option::Option::None" |) 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",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/reference_safety/mod.rs:187 (none)"
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.path
                                                                      "core::fmt::rt::Argument",
                                                                    "none",
                                                                    []
                                                                  |),
                                                                  []
                                                                |)
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) 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~ frozen :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::ops::try_trait::Try",
                                    Ty.apply
                                      (Ty.path "core::result::Result")
                                      []
                                      [
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [],
                                    "branch",
                                    []
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "freeze_ref",
                                        []
                                      |),
                                      [ M.read (| state |); M.read (| offset |); M.read (| id |) ]
                                    |)
                                  ]
                                |)
                              |),
                              [
                                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_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| frozen |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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.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~ v1 :=
                                      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_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                  ],
                                                "pop",
                                                []
                                              |),
                                              [
                                                M.SubPointer.get_struct_record_field (|
                                                  M.read (| verifier |),
                                                  "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                  "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/reference_safety/mod.rs:192 "
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          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~ v2 :=
                                      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_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                  ],
                                                "pop",
                                                []
                                              |),
                                              [
                                                M.SubPointer.get_struct_record_field (|
                                                  M.read (| verifier |),
                                                  "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                  "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/reference_safety/mod.rs:193 "
                                                                                |)
                                                                              ]
                                                                          |);
                                                                          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~ value :=
                                      M.copy (|
                                        M.match_operator (|
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_trait_method (|
                                                "core::ops::try_trait::Try",
                                                Ty.apply
                                                  (Ty.path "core::result::Result")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                                    Ty.path
                                                      "move_binary_format::errors::PartialVMError"
                                                  ],
                                                [],
                                                "branch",
                                                []
                                              |),
                                              [
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path
                                                      "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                                    "comparison",
                                                    []
                                                  |),
                                                  [
                                                    M.read (| state |);
                                                    M.read (| offset |);
                                                    M.read (| v1 |);
                                                    M.read (| v2 |)
                                                  ]
                                                |)
                                              ]
                                            |)
                                          |),
                                          [
                                            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_associated_function (|
                                                Ty.path
                                                  "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                "push",
                                                []
                                              |),
                                              [ M.read (| verifier |); M.read (| value |) ]
                                            |)
                                          ]
                                        |)
                                      |),
                                      [
                                        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))
                                      ]
                                    |)))
                                | _ => 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::ReadRef"
                          |) in
                        let~ id :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                    "ref_id",
                                    []
                                  |),
                                  [
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.apply
                                              (Ty.path "move_abstract_stack::AbstractStack")
                                              []
                                              [
                                                Ty.path
                                                  "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                              ],
                                            "pop",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_struct_record_field (|
                                              M.read (| verifier |),
                                              "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                              "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/reference_safety/mod.rs:198 "
                                                                            |)
                                                                          ]
                                                                      |);
                                                                      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 |) ]
                                                          |)
                                                        |)
                                                      |)
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::option::Option::Some",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (| γ, "core::option::Option::None" |) 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",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/reference_safety/mod.rs:198 (none)"
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.path
                                                                      "core::fmt::rt::Argument",
                                                                    "none",
                                                                    []
                                                                  |),
                                                                  []
                                                                |)
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) 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~ value :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::ops::try_trait::Try",
                                    Ty.apply
                                      (Ty.path "core::result::Result")
                                      []
                                      [
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [],
                                    "branch",
                                    []
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "read_ref",
                                        []
                                      |),
                                      [ M.read (| state |); M.read (| offset |); M.read (| id |) ]
                                    |)
                                  ]
                                |)
                              |),
                              [
                                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_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| value |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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::WriteRef"
                          |) in
                        let~ id :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                    "ref_id",
                                    []
                                  |),
                                  [
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.apply
                                              (Ty.path "move_abstract_stack::AbstractStack")
                                              []
                                              [
                                                Ty.path
                                                  "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                              ],
                                            "pop",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_struct_record_field (|
                                              M.read (| verifier |),
                                              "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                              "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/reference_safety/mod.rs:203 "
                                                                            |)
                                                                          ]
                                                                      |);
                                                                      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 |) ]
                                                          |)
                                                        |)
                                                      |)
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::option::Option::Some",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (| γ, "core::option::Option::None" |) 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",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/reference_safety/mod.rs:203 (none)"
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.path
                                                                      "core::fmt::rt::Argument",
                                                                    "none",
                                                                    []
                                                                  |),
                                                                  []
                                                                |)
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) 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_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                      ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                      "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/reference_safety/mod.rs:204 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              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_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                              "is_value",
                                              []
                                            |),
                                            [ val_operand ]
                                          |)
                                        |)
                                      |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) 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",
                                                            []
                                                          |),
                                                          [
                                                            M.alloc (|
                                                              Value.Array
                                                                [
                                                                  M.read (|
                                                                    Value.String
                                                                      "crates/move-bytecode-verifier/src/reference_safety/mod.rs:205 (assert)"
                                                                  |)
                                                                ]
                                                            |);
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "none",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) 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 |) ]
                                                |)
                                              |)
                                            |)
                                          |)))
                                    ]
                                  |)));
                              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::reference_safety::abstract_state::AbstractState",
                                    "write_ref",
                                    []
                                  |),
                                  [ M.read (| state |); M.read (| offset |); M.read (| id |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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 local := M.alloc (| γ1_0 |) in
                        let~ value :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::ops::try_trait::Try",
                                    Ty.apply
                                      (Ty.path "core::result::Result")
                                      []
                                      [
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [],
                                    "branch",
                                    []
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "borrow_loc",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        M.read (| offset |);
                                        Value.Bool true;
                                        M.read (| M.read (| local |) |)
                                      ]
                                    |)
                                  ]
                                |)
                              |),
                              [
                                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_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| value |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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 local := M.alloc (| γ1_0 |) in
                        let~ value :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::ops::try_trait::Try",
                                    Ty.apply
                                      (Ty.path "core::result::Result")
                                      []
                                      [
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [],
                                    "branch",
                                    []
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "borrow_loc",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        M.read (| offset |);
                                        Value.Bool false;
                                        M.read (| M.read (| local |) |)
                                      ]
                                    |)
                                  ]
                                |)
                              |),
                              [
                                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_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| value |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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::MutBorrowField",
                            0
                          |) in
                        let field_handle_index := M.alloc (| γ1_0 |) in
                        let~ id :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                    "ref_id",
                                    []
                                  |),
                                  [
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.apply
                                              (Ty.path "move_abstract_stack::AbstractStack")
                                              []
                                              [
                                                Ty.path
                                                  "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                              ],
                                            "pop",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_struct_record_field (|
                                              M.read (| verifier |),
                                              "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                              "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/reference_safety/mod.rs:218 "
                                                                            |)
                                                                          ]
                                                                      |);
                                                                      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 |) ]
                                                          |)
                                                        |)
                                                      |)
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::option::Option::Some",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (| γ, "core::option::Option::None" |) 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",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/reference_safety/mod.rs:218 (none)"
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.path
                                                                      "core::fmt::rt::Argument",
                                                                    "none",
                                                                    []
                                                                  |),
                                                                  []
                                                                |)
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) 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~ value :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::ops::try_trait::Try",
                                    Ty.apply
                                      (Ty.path "core::result::Result")
                                      []
                                      [
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [],
                                    "branch",
                                    []
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "borrow_field",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        M.read (| offset |);
                                        Value.Bool true;
                                        M.read (| id |);
                                        M.read (| M.read (| field_handle_index |) |)
                                      ]
                                    |)
                                  ]
                                |)
                              |),
                              [
                                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_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| value |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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::reference_safety::ReferenceSafetyAnalysis",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| field_inst_index |) |)
                              ]
                            |)
                          |) in
                        let~ id :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                    "ref_id",
                                    []
                                  |),
                                  [
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.apply
                                              (Ty.path "move_abstract_stack::AbstractStack")
                                              []
                                              [
                                                Ty.path
                                                  "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                              ],
                                            "pop",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_struct_record_field (|
                                              M.read (| verifier |),
                                              "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                              "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/reference_safety/mod.rs:224 "
                                                                            |)
                                                                          ]
                                                                      |);
                                                                      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 |) ]
                                                          |)
                                                        |)
                                                      |)
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::option::Option::Some",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (| γ, "core::option::Option::None" |) 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",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/reference_safety/mod.rs:224 (none)"
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.path
                                                                      "core::fmt::rt::Argument",
                                                                    "none",
                                                                    []
                                                                  |),
                                                                  []
                                                                |)
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) 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~ value :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::ops::try_trait::Try",
                                    Ty.apply
                                      (Ty.path "core::result::Result")
                                      []
                                      [
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [],
                                    "branch",
                                    []
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "borrow_field",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        M.read (| offset |);
                                        Value.Bool true;
                                        M.read (| id |);
                                        M.read (|
                                          M.SubPointer.get_struct_record_field (|
                                            M.read (| field_inst |),
                                            "move_binary_format::file_format::FieldInstantiation",
                                            "handle"
                                          |)
                                        |)
                                      ]
                                    |)
                                  ]
                                |)
                              |),
                              [
                                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_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| value |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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
                        let~ id :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                    "ref_id",
                                    []
                                  |),
                                  [
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.apply
                                              (Ty.path "move_abstract_stack::AbstractStack")
                                              []
                                              [
                                                Ty.path
                                                  "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                              ],
                                            "pop",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_struct_record_field (|
                                              M.read (| verifier |),
                                              "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                              "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/reference_safety/mod.rs:229 "
                                                                            |)
                                                                          ]
                                                                      |);
                                                                      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 |) ]
                                                          |)
                                                        |)
                                                      |)
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::option::Option::Some",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (| γ, "core::option::Option::None" |) 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",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/reference_safety/mod.rs:229 (none)"
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.path
                                                                      "core::fmt::rt::Argument",
                                                                    "none",
                                                                    []
                                                                  |),
                                                                  []
                                                                |)
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) 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~ value :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::ops::try_trait::Try",
                                    Ty.apply
                                      (Ty.path "core::result::Result")
                                      []
                                      [
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [],
                                    "branch",
                                    []
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "borrow_field",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        M.read (| offset |);
                                        Value.Bool false;
                                        M.read (| id |);
                                        M.read (| M.read (| field_handle_index |) |)
                                      ]
                                    |)
                                  ]
                                |)
                              |),
                              [
                                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_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| value |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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::reference_safety::ReferenceSafetyAnalysis",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| field_inst_index |) |)
                              ]
                            |)
                          |) in
                        let~ id :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                    "ref_id",
                                    []
                                  |),
                                  [
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.apply
                                              (Ty.path "move_abstract_stack::AbstractStack")
                                              []
                                              [
                                                Ty.path
                                                  "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                              ],
                                            "pop",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_struct_record_field (|
                                              M.read (| verifier |),
                                              "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                              "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/reference_safety/mod.rs:235 "
                                                                            |)
                                                                          ]
                                                                      |);
                                                                      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 |) ]
                                                          |)
                                                        |)
                                                      |)
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::option::Option::Some",
                                        0
                                      |) in
                                    let x := M.copy (| γ0_0 |) in
                                    x));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (| γ, "core::option::Option::None" |) 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",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/reference_safety/mod.rs:235 (none)"
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.path
                                                                      "core::fmt::rt::Argument",
                                                                    "none",
                                                                    []
                                                                  |),
                                                                  []
                                                                |)
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) 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~ value :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::ops::try_trait::Try",
                                    Ty.apply
                                      (Ty.path "core::result::Result")
                                      []
                                      [
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [],
                                    "branch",
                                    []
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "borrow_field",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        M.read (| offset |);
                                        Value.Bool false;
                                        M.read (| id |);
                                        M.read (|
                                          M.SubPointer.get_struct_record_field (|
                                            M.read (| field_inst |),
                                            "move_binary_format::file_format::FieldInstantiation",
                                            "handle"
                                          |)
                                        |)
                                      ]
                                    |)
                                  ]
                                |)
                              |),
                              [
                                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_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| value |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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::MutBorrowGlobalDeprecated",
                            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 (|
                                        UnOp.not (|
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path
                                                "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                              "is_value",
                                              []
                                            |),
                                            [
                                              M.match_operator (|
                                                M.alloc (|
                                                  M.call_closure (|
                                                    M.get_associated_function (|
                                                      Ty.apply
                                                        (Ty.path
                                                          "move_abstract_stack::AbstractStack")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                        ],
                                                      "pop",
                                                      []
                                                    |),
                                                    [
                                                      M.SubPointer.get_struct_record_field (|
                                                        M.read (| verifier |),
                                                        "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                        "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/reference_safety/mod.rs:241 "
                                                                                      |)
                                                                                    ]
                                                                                |);
                                                                                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.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) 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",
                                                            []
                                                          |),
                                                          [
                                                            M.alloc (|
                                                              Value.Array
                                                                [
                                                                  M.read (|
                                                                    Value.String
                                                                      "crates/move-bytecode-verifier/src/reference_safety/mod.rs:241 (assert)"
                                                                  |)
                                                                ]
                                                            |);
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "none",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) 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 |) ]
                                                |)
                                              |)
                                            |)
                                          |)))
                                    ]
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) in
                        let~ value :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::ops::try_trait::Try",
                                    Ty.apply
                                      (Ty.path "core::result::Result")
                                      []
                                      [
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [],
                                    "branch",
                                    []
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "borrow_global",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        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))
                              ]
                            |)
                          |) 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::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| value |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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~ _ :=
                          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_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                              "is_value",
                                              []
                                            |),
                                            [
                                              M.match_operator (|
                                                M.alloc (|
                                                  M.call_closure (|
                                                    M.get_associated_function (|
                                                      Ty.apply
                                                        (Ty.path
                                                          "move_abstract_stack::AbstractStack")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                        ],
                                                      "pop",
                                                      []
                                                    |),
                                                    [
                                                      M.SubPointer.get_struct_record_field (|
                                                        M.read (| verifier |),
                                                        "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                        "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/reference_safety/mod.rs:246 "
                                                                                      |)
                                                                                    ]
                                                                                |);
                                                                                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.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) 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",
                                                            []
                                                          |),
                                                          [
                                                            M.alloc (|
                                                              Value.Array
                                                                [
                                                                  M.read (|
                                                                    Value.String
                                                                      "crates/move-bytecode-verifier/src/reference_safety/mod.rs:246 (assert)"
                                                                  |)
                                                                ]
                                                            |);
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "none",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) 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 |) ]
                                                |)
                                              |)
                                            |)
                                          |)))
                                    ]
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) 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::reference_safety::ReferenceSafetyAnalysis",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| idx |) |)
                              ]
                            |)
                          |) in
                        let~ value :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::ops::try_trait::Try",
                                    Ty.apply
                                      (Ty.path "core::result::Result")
                                      []
                                      [
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [],
                                    "branch",
                                    []
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "borrow_global",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        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"
                                          |)
                                        |)
                                      ]
                                    |)
                                  ]
                                |)
                              |),
                              [
                                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_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| value |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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
                        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_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                              "is_value",
                                              []
                                            |),
                                            [
                                              M.match_operator (|
                                                M.alloc (|
                                                  M.call_closure (|
                                                    M.get_associated_function (|
                                                      Ty.apply
                                                        (Ty.path
                                                          "move_abstract_stack::AbstractStack")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                        ],
                                                      "pop",
                                                      []
                                                    |),
                                                    [
                                                      M.SubPointer.get_struct_record_field (|
                                                        M.read (| verifier |),
                                                        "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                        "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/reference_safety/mod.rs:252 "
                                                                                      |)
                                                                                    ]
                                                                                |);
                                                                                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.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) 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",
                                                            []
                                                          |),
                                                          [
                                                            M.alloc (|
                                                              Value.Array
                                                                [
                                                                  M.read (|
                                                                    Value.String
                                                                      "crates/move-bytecode-verifier/src/reference_safety/mod.rs:252 (assert)"
                                                                  |)
                                                                ]
                                                            |);
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "none",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) 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 |) ]
                                                |)
                                              |)
                                            |)
                                          |)))
                                    ]
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) in
                        let~ value :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::ops::try_trait::Try",
                                    Ty.apply
                                      (Ty.path "core::result::Result")
                                      []
                                      [
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [],
                                    "branch",
                                    []
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "borrow_global",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        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))
                              ]
                            |)
                          |) 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::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| value |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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~ _ :=
                          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_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                              "is_value",
                                              []
                                            |),
                                            [
                                              M.match_operator (|
                                                M.alloc (|
                                                  M.call_closure (|
                                                    M.get_associated_function (|
                                                      Ty.apply
                                                        (Ty.path
                                                          "move_abstract_stack::AbstractStack")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                        ],
                                                      "pop",
                                                      []
                                                    |),
                                                    [
                                                      M.SubPointer.get_struct_record_field (|
                                                        M.read (| verifier |),
                                                        "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                        "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/reference_safety/mod.rs:257 "
                                                                                      |)
                                                                                    ]
                                                                                |);
                                                                                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.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) 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",
                                                            []
                                                          |),
                                                          [
                                                            M.alloc (|
                                                              Value.Array
                                                                [
                                                                  M.read (|
                                                                    Value.String
                                                                      "crates/move-bytecode-verifier/src/reference_safety/mod.rs:257 (assert)"
                                                                  |)
                                                                ]
                                                            |);
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "none",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) 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 |) ]
                                                |)
                                              |)
                                            |)
                                          |)))
                                    ]
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) 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::reference_safety::ReferenceSafetyAnalysis",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| idx |) |)
                              ]
                            |)
                          |) in
                        let~ value :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::ops::try_trait::Try",
                                    Ty.apply
                                      (Ty.path "core::result::Result")
                                      []
                                      [
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [],
                                    "branch",
                                    []
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "borrow_global",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        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"
                                          |)
                                        |)
                                      ]
                                    |)
                                  ]
                                |)
                              |),
                              [
                                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_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| value |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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~ _ :=
                          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_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                              "is_value",
                                              []
                                            |),
                                            [
                                              M.match_operator (|
                                                M.alloc (|
                                                  M.call_closure (|
                                                    M.get_associated_function (|
                                                      Ty.apply
                                                        (Ty.path
                                                          "move_abstract_stack::AbstractStack")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                        ],
                                                      "pop",
                                                      []
                                                    |),
                                                    [
                                                      M.SubPointer.get_struct_record_field (|
                                                        M.read (| verifier |),
                                                        "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                        "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/reference_safety/mod.rs:263 "
                                                                                      |)
                                                                                    ]
                                                                                |);
                                                                                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.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) 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",
                                                            []
                                                          |),
                                                          [
                                                            M.alloc (|
                                                              Value.Array
                                                                [
                                                                  M.read (|
                                                                    Value.String
                                                                      "crates/move-bytecode-verifier/src/reference_safety/mod.rs:263 (assert)"
                                                                  |)
                                                                ]
                                                            |);
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "none",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) 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 |) ]
                                                |)
                                              |)
                                            |)
                                          |)))
                                    ]
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) in
                        let~ value :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::ops::try_trait::Try",
                                    Ty.apply
                                      (Ty.path "core::result::Result")
                                      []
                                      [
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [],
                                    "branch",
                                    []
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "move_from",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        M.read (| offset |);
                                        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))
                              ]
                            |)
                          |) 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::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| value |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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~ _ :=
                          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_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                              "is_value",
                                              []
                                            |),
                                            [
                                              M.match_operator (|
                                                M.alloc (|
                                                  M.call_closure (|
                                                    M.get_associated_function (|
                                                      Ty.apply
                                                        (Ty.path
                                                          "move_abstract_stack::AbstractStack")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                        ],
                                                      "pop",
                                                      []
                                                    |),
                                                    [
                                                      M.SubPointer.get_struct_record_field (|
                                                        M.read (| verifier |),
                                                        "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                        "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/reference_safety/mod.rs:268 "
                                                                                      |)
                                                                                    ]
                                                                                |);
                                                                                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.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) 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",
                                                            []
                                                          |),
                                                          [
                                                            M.alloc (|
                                                              Value.Array
                                                                [
                                                                  M.read (|
                                                                    Value.String
                                                                      "crates/move-bytecode-verifier/src/reference_safety/mod.rs:268 (assert)"
                                                                  |)
                                                                ]
                                                            |);
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "none",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) 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 |) ]
                                                |)
                                              |)
                                            |)
                                          |)))
                                    ]
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) 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::reference_safety::ReferenceSafetyAnalysis",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| idx |) |)
                              ]
                            |)
                          |) in
                        let~ value :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::ops::try_trait::Try",
                                    Ty.apply
                                      (Ty.path "core::result::Result")
                                      []
                                      [
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [],
                                    "branch",
                                    []
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "move_from",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        M.read (| offset |);
                                        M.read (|
                                          M.SubPointer.get_struct_record_field (|
                                            M.read (| struct_inst |),
                                            "move_binary_format::file_format::StructDefInstantiation",
                                            "def"
                                          |)
                                        |)
                                      ]
                                    |)
                                  ]
                                |)
                              |),
                              [
                                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_associated_function (|
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| value |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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::reference_safety::ReferenceSafetyAnalysis",
                                    "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::reference_safety::call",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| state |);
                                    M.read (| offset |);
                                    M.read (| function_handle |);
                                    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))
                          ]
                        |)));
                    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::reference_safety::ReferenceSafetyAnalysis",
                                    "module"
                                  |)
                                |);
                                M.read (| M.read (| idx |) |)
                              ]
                            |)
                          |) 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::reference_safety::ReferenceSafetyAnalysis",
                                    "module"
                                  |)
                                |);
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| func_inst |),
                                    "move_binary_format::file_format::FunctionInstantiation",
                                    "handle"
                                  |)
                                |)
                              ]
                            |)
                          |) 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::reference_safety::call",
                                    [ impl_Meter__plus___Sized ]
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.read (| state |);
                                    M.read (| offset |);
                                    M.read (| function_handle |);
                                    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))
                          ]
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let _ :=
                          M.is_struct_tuple (|
                            γ,
                            "move_binary_format::file_format::Bytecode::Ret"
                          |) in
                        let~ return_values :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.apply
                                  (Ty.path "alloc::vec::Vec")
                                  []
                                  [
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                    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::ops::range::Range")
                                      []
                                      [ Ty.path "usize" ],
                                    [],
                                    "into_iter",
                                    []
                                  |),
                                  [
                                    Value.StructRecord
                                      "core::ops::range::Range"
                                      [
                                        ("start", Value.Integer IntegerKind.Usize 0);
                                        ("end_",
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "move_binary_format::file_format::Signature",
                                              "len",
                                              []
                                            |),
                                            [
                                              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::reference_safety::ReferenceSafetyAnalysis",
                                                      "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 "core::ops::range::Range")
                                                    []
                                                    [ Ty.path "usize" ],
                                                  [],
                                                  "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~ _ :=
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_associated_function (|
                                                          Ty.apply
                                                            (Ty.path "alloc::vec::Vec")
                                                            []
                                                            [
                                                              Ty.path
                                                                "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                                              Ty.path "alloc::alloc::Global"
                                                            ],
                                                          "push",
                                                          []
                                                        |),
                                                        [
                                                          return_values;
                                                          M.read (|
                                                            M.match_operator (|
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "move_abstract_stack::AbstractStack")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                                      ],
                                                                    "pop",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_struct_record_field (|
                                                                      M.read (| verifier |),
                                                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                                      "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/reference_safety/mod.rs:287 "
                                                                                                    |)
                                                                                                  ]
                                                                                              |);
                                                                                              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.Tuple [] |)))
                                            ]
                                          |) in
                                        M.alloc (| Value.Tuple [] |)))
                                    |)))
                              ]
                            |)) in
                        let~ _ :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.apply
                                  (Ty.path "slice")
                                  []
                                  [
                                    Ty.path
                                      "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                  ],
                                "reverse",
                                []
                              |),
                              [
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::ops::deref::DerefMut",
                                    Ty.apply
                                      (Ty.path "alloc::vec::Vec")
                                      []
                                      [
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                        Ty.path "alloc::alloc::Global"
                                      ],
                                    [],
                                    "deref_mut",
                                    []
                                  |),
                                  [ return_values ]
                                |)
                              ]
                            |)
                          |) 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::reference_safety::abstract_state::AbstractState",
                                    "ret",
                                    []
                                  |),
                                  [
                                    M.read (| state |);
                                    M.read (| offset |);
                                    M.read (| return_values |)
                                  ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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.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 []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::CastU8"
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::CastU16"
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::CastU32"
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::CastU64"
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::CastU128"
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::CastU256"
                                  |) in
                                Value.Tuple []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::Not"
                                  |) 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::ExistsDeprecated",
                                    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::ExistsGenericDeprecated",
                                    0
                                  |) 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
                        (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 []));
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let _ :=
                                  M.is_struct_tuple (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::Abort"
                                  |) in
                                Value.Tuple []))
                          ],
                          M.closure
                            (fun γ =>
                              ltac:(M.monadic
                                match γ with
                                | [] =>
                                  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_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                                          "is_value",
                                                          []
                                                        |),
                                                        [
                                                          M.match_operator (|
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.apply
                                                                    (Ty.path
                                                                      "move_abstract_stack::AbstractStack")
                                                                    []
                                                                    [
                                                                      Ty.path
                                                                        "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                                    ],
                                                                  "pop",
                                                                  []
                                                                |),
                                                                [
                                                                  M.SubPointer.get_struct_record_field (|
                                                                    M.read (| verifier |),
                                                                    "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                                    "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/reference_safety/mod.rs:307 "
                                                                                                  |)
                                                                                                ]
                                                                                            |);
                                                                                            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.is_constant_or_break_match (|
                                                  M.read (| γ |),
                                                  Value.Bool true
                                                |) 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",
                                                                        []
                                                                      |),
                                                                      [
                                                                        M.alloc (|
                                                                          Value.Array
                                                                            [
                                                                              M.read (|
                                                                                Value.String
                                                                                  "crates/move-bytecode-verifier/src/reference_safety/mod.rs:307 (assert)"
                                                                              |)
                                                                            ]
                                                                        |);
                                                                        M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::Argument",
                                                                              "none",
                                                                              []
                                                                            |),
                                                                            []
                                                                          |)
                                                                        |)
                                                                      ]
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) 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 |) ]
                                                            |)
                                                          |)
                                                        |)
                                                      |)))
                                                ]
                                              |)));
                                          fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                        ]
                                      |) in
                                    M.alloc (| Value.Tuple [] |)))
                                | _ => M.impossible "wrong number of arguments"
                                end))
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (M.find_or_pattern (|
                          γ,
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (let γ := M.read (| γ |) in
                                let γ1_0 :=
                                  M.SubPointer.get_struct_tuple_field (|
                                    γ,
                                    "move_binary_format::file_format::Bytecode::MoveToDeprecated",
                                    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::MoveToGenericDeprecated",
                                    0
                                  |) in
                                Value.Tuple []))
                          ],
                          M.closure
                            (fun γ =>
                              ltac:(M.monadic
                                match γ with
                                | [] =>
                                  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_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                                          "is_value",
                                                          []
                                                        |),
                                                        [
                                                          M.match_operator (|
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.apply
                                                                    (Ty.path
                                                                      "move_abstract_stack::AbstractStack")
                                                                    []
                                                                    [
                                                                      Ty.path
                                                                        "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                                    ],
                                                                  "pop",
                                                                  []
                                                                |),
                                                                [
                                                                  M.SubPointer.get_struct_record_field (|
                                                                    M.read (| verifier |),
                                                                    "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                                    "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/reference_safety/mod.rs:311 "
                                                                                                  |)
                                                                                                ]
                                                                                            |);
                                                                                            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.is_constant_or_break_match (|
                                                  M.read (| γ |),
                                                  Value.Bool true
                                                |) 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",
                                                                        []
                                                                      |),
                                                                      [
                                                                        M.alloc (|
                                                                          Value.Array
                                                                            [
                                                                              M.read (|
                                                                                Value.String
                                                                                  "crates/move-bytecode-verifier/src/reference_safety/mod.rs:311 (assert)"
                                                                              |)
                                                                            ]
                                                                        |);
                                                                        M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::Argument",
                                                                              "none",
                                                                              []
                                                                            |),
                                                                            []
                                                                          |)
                                                                        |)
                                                                      ]
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) 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 |) ]
                                                            |)
                                                          |)
                                                        |)
                                                      |)))
                                                ]
                                              |)));
                                          fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                        ]
                                      |) in
                                    let~ _ :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path
                                              "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                            "release_value",
                                            []
                                          |),
                                          [
                                            M.read (| state |);
                                            M.read (|
                                              M.match_operator (|
                                                M.alloc (|
                                                  M.call_closure (|
                                                    M.get_associated_function (|
                                                      Ty.apply
                                                        (Ty.path
                                                          "move_abstract_stack::AbstractStack")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                        ],
                                                      "pop",
                                                      []
                                                    |),
                                                    [
                                                      M.SubPointer.get_struct_record_field (|
                                                        M.read (| verifier |),
                                                        "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                        "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/reference_safety/mod.rs:313 "
                                                                                      |)
                                                                                    ]
                                                                                |);
                                                                                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.Tuple [] |)))
                                | _ => 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::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
                                    (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::reference_safety::ReferenceSafetyAnalysis",
                                                "push",
                                                []
                                              |),
                                              [
                                                M.read (| verifier |);
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path
                                                      "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                                    "value_for",
                                                    []
                                                  |),
                                                  [
                                                    M.read (| state |);
                                                    M.alloc (|
                                                      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))
                                      ]
                                    |)))
                                | _ => 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::LdU8",
                            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::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "value_for",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        M.alloc (|
                                          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))
                          ]
                        |)));
                    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
                        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::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "value_for",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        M.alloc (|
                                          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))
                          ]
                        |)));
                    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
                        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::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "value_for",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        M.alloc (|
                                          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))
                          ]
                        |)));
                    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
                        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::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "value_for",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        M.alloc (|
                                          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))
                          ]
                        |)));
                    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
                        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::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "value_for",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        M.alloc (|
                                          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))
                          ]
                        |)));
                    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
                        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::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "value_for",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        M.alloc (|
                                          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))
                          ]
                        |)));
                    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.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::reference_safety::ReferenceSafetyAnalysis",
                                      "module"
                                    |)
                                  |);
                                  M.read (| M.read (| idx |) |)
                                ]
                              |),
                              "move_binary_format::file_format::Constant",
                              "type_"
                            |)
                          |) 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::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "value_for",
                                        []
                                      |),
                                      [ M.read (| state |); 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))
                          ]
                        |)));
                    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 []));
                            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 []));
                            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 []));
                            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~ _ :=
                                      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_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                                          "is_value",
                                                          []
                                                        |),
                                                        [
                                                          M.match_operator (|
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.apply
                                                                    (Ty.path
                                                                      "move_abstract_stack::AbstractStack")
                                                                    []
                                                                    [
                                                                      Ty.path
                                                                        "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                                    ],
                                                                  "pop",
                                                                  []
                                                                |),
                                                                [
                                                                  M.SubPointer.get_struct_record_field (|
                                                                    M.read (| verifier |),
                                                                    "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                                    "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/reference_safety/mod.rs:346 "
                                                                                                  |)
                                                                                                ]
                                                                                            |);
                                                                                            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.is_constant_or_break_match (|
                                                  M.read (| γ |),
                                                  Value.Bool true
                                                |) 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",
                                                                        []
                                                                      |),
                                                                      [
                                                                        M.alloc (|
                                                                          Value.Array
                                                                            [
                                                                              M.read (|
                                                                                Value.String
                                                                                  "crates/move-bytecode-verifier/src/reference_safety/mod.rs:346 (assert)"
                                                                              |)
                                                                            ]
                                                                        |);
                                                                        M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::Argument",
                                                                              "none",
                                                                              []
                                                                            |),
                                                                            []
                                                                          |)
                                                                        |)
                                                                      ]
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) 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 |) ]
                                                            |)
                                                          |)
                                                        |)
                                                      |)))
                                                ]
                                              |)));
                                          fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                        ]
                                      |) 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_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                                          "is_value",
                                                          []
                                                        |),
                                                        [
                                                          M.match_operator (|
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.apply
                                                                    (Ty.path
                                                                      "move_abstract_stack::AbstractStack")
                                                                    []
                                                                    [
                                                                      Ty.path
                                                                        "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                                    ],
                                                                  "pop",
                                                                  []
                                                                |),
                                                                [
                                                                  M.SubPointer.get_struct_record_field (|
                                                                    M.read (| verifier |),
                                                                    "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                                    "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/reference_safety/mod.rs:347 "
                                                                                                  |)
                                                                                                ]
                                                                                            |);
                                                                                            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.is_constant_or_break_match (|
                                                  M.read (| γ |),
                                                  Value.Bool true
                                                |) 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",
                                                                        []
                                                                      |),
                                                                      [
                                                                        M.alloc (|
                                                                          Value.Array
                                                                            [
                                                                              M.read (|
                                                                                Value.String
                                                                                  "crates/move-bytecode-verifier/src/reference_safety/mod.rs:347 (assert)"
                                                                              |)
                                                                            ]
                                                                        |);
                                                                        M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.path
                                                                                "core::fmt::rt::Argument",
                                                                              "none",
                                                                              []
                                                                            |),
                                                                            []
                                                                          |)
                                                                        |)
                                                                      ]
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) 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 |) ]
                                                            |)
                                                          |)
                                                        |)
                                                      |)))
                                                ]
                                              |)));
                                          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::reference_safety::ReferenceSafetyAnalysis",
                                                "push",
                                                []
                                              |),
                                              [
                                                M.read (| verifier |);
                                                Value.StructTuple
                                                  "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue::NonReference"
                                                  []
                                              ]
                                            |)
                                          ]
                                        |)
                                      |),
                                      [
                                        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))
                                      ]
                                    |)))
                                | _ => M.impossible "wrong number of arguments"
                                end))
                        |)));
                    fun γ =>
                      ltac:(M.monadic
                        (let γ := M.read (| γ |) in
                        let γ1_0 :=
                          M.SubPointer.get_struct_tuple_field (|
                            γ,
                            "move_binary_format::file_format::Bytecode::Pack",
                            0
                          |) in
                        let 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::reference_safety::ReferenceSafetyAnalysis",
                                    "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::reference_safety::pack",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| struct_def |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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::reference_safety::ReferenceSafetyAnalysis",
                                    "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::reference_safety::ReferenceSafetyAnalysis",
                                    "module"
                                  |)
                                |);
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| struct_inst |),
                                    "move_binary_format::file_format::StructDefInstantiation",
                                    "def"
                                  |)
                                |)
                              ]
                            |)
                          |) 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::reference_safety::pack",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| struct_def |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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_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::reference_safety::ReferenceSafetyAnalysis",
                                    "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::reference_safety::unpack",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| struct_def |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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::reference_safety::ReferenceSafetyAnalysis",
                                    "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::reference_safety::ReferenceSafetyAnalysis",
                                    "module"
                                  |)
                                |);
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| struct_inst |),
                                    "move_binary_format::file_format::StructDefInstantiation",
                                    "def"
                                  |)
                                |)
                              ]
                            |)
                          |) 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::reference_safety::unpack",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| struct_def |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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~ _ :=
                          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~ result :=
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.apply
                                            (Ty.path "move_abstract_stack::AbstractStack")
                                            []
                                            [
                                              Ty.path
                                                "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                            ],
                                          "pop_eq_n",
                                          []
                                        |),
                                        [
                                          M.SubPointer.get_struct_record_field (|
                                            M.read (| verifier |),
                                            "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                            "stack"
                                          |);
                                          M.read (| num_to_pop |)
                                        ]
                                      |)
                                    |) in
                                  let~ abs_value :=
                                    M.copy (|
                                      M.match_operator (|
                                        result,
                                        [
                                          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/reference_safety/mod.rs:374 "
                                                                              |)
                                                                            ]
                                                                        |);
                                                                        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_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                                        "is_value",
                                                        []
                                                      |),
                                                      [ abs_value ]
                                                    |)
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) 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",
                                                                      []
                                                                    |),
                                                                    [
                                                                      M.alloc (|
                                                                        Value.Array
                                                                          [
                                                                            M.read (|
                                                                              Value.String
                                                                                "crates/move-bytecode-verifier/src/reference_safety/mod.rs:375 (assert)"
                                                                            |)
                                                                          ]
                                                                      |);
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_associated_function (|
                                                                            Ty.path
                                                                              "core::fmt::rt::Argument",
                                                                            "none",
                                                                            []
                                                                          |),
                                                                          []
                                                                        |)
                                                                      |)
                                                                    ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |) 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 |) ]
                                                          |)
                                                        |)
                                                      |)
                                                    |)))
                                              ]
                                            |)));
                                        fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                      ]
                                    |) in
                                  M.alloc (| Value.Tuple [] |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) in
                        let~ element_type :=
                          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::SignatureToken";
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [],
                                    "branch",
                                    []
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_function (|
                                        "move_bytecode_verifier::reference_safety::vec_element_type",
                                        []
                                      |),
                                      [ M.read (| verifier |); 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))
                              ]
                            |)
                          |) 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::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "value_for",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        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.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))
                          ]
                        |)));
                    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~ vec_ref :=
                          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_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                      ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                      "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/reference_safety/mod.rs:383 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              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 (|
                              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::reference_safety::abstract_state::AbstractState",
                                      "vector_op",
                                      []
                                    |),
                                    [
                                      M.read (| state |);
                                      M.read (| offset |);
                                      M.read (| vec_ref |);
                                      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))
                            ]
                          |) 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::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "value_for",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        M.alloc (|
                                          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))
                          ]
                        |)));
                    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~ _ :=
                          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_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                              "is_value",
                                              []
                                            |),
                                            [
                                              M.match_operator (|
                                                M.alloc (|
                                                  M.call_closure (|
                                                    M.get_associated_function (|
                                                      Ty.apply
                                                        (Ty.path
                                                          "move_abstract_stack::AbstractStack")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                        ],
                                                      "pop",
                                                      []
                                                    |),
                                                    [
                                                      M.SubPointer.get_struct_record_field (|
                                                        M.read (| verifier |),
                                                        "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                        "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/reference_safety/mod.rs:389 "
                                                                                      |)
                                                                                    ]
                                                                                |);
                                                                                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.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) 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",
                                                            []
                                                          |),
                                                          [
                                                            M.alloc (|
                                                              Value.Array
                                                                [
                                                                  M.read (|
                                                                    Value.String
                                                                      "crates/move-bytecode-verifier/src/reference_safety/mod.rs:389 (assert)"
                                                                  |)
                                                                ]
                                                            |);
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "none",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) 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 |) ]
                                                |)
                                              |)
                                            |)
                                          |)))
                                    ]
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) in
                        let~ vec_ref :=
                          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_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                      ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                      "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/reference_safety/mod.rs:390 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              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~ elem_ref :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::ops::try_trait::Try",
                                    Ty.apply
                                      (Ty.path "core::result::Result")
                                      []
                                      [
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [],
                                    "branch",
                                    []
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "vector_element_borrow",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        M.read (| offset |);
                                        M.read (| vec_ref |);
                                        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))
                              ]
                            |)
                          |) 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::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| elem_ref |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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~ _ :=
                          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_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                              "is_value",
                                              []
                                            |),
                                            [
                                              M.match_operator (|
                                                M.alloc (|
                                                  M.call_closure (|
                                                    M.get_associated_function (|
                                                      Ty.apply
                                                        (Ty.path
                                                          "move_abstract_stack::AbstractStack")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                        ],
                                                      "pop",
                                                      []
                                                    |),
                                                    [
                                                      M.SubPointer.get_struct_record_field (|
                                                        M.read (| verifier |),
                                                        "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                        "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/reference_safety/mod.rs:395 "
                                                                                      |)
                                                                                    ]
                                                                                |);
                                                                                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.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) 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",
                                                            []
                                                          |),
                                                          [
                                                            M.alloc (|
                                                              Value.Array
                                                                [
                                                                  M.read (|
                                                                    Value.String
                                                                      "crates/move-bytecode-verifier/src/reference_safety/mod.rs:395 (assert)"
                                                                  |)
                                                                ]
                                                            |);
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "none",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) 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 |) ]
                                                |)
                                              |)
                                            |)
                                          |)))
                                    ]
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) in
                        let~ vec_ref :=
                          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_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                      ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                      "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/reference_safety/mod.rs:396 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              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~ elem_ref :=
                          M.copy (|
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::ops::try_trait::Try",
                                    Ty.apply
                                      (Ty.path "core::result::Result")
                                      []
                                      [
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue";
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [],
                                    "branch",
                                    []
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "vector_element_borrow",
                                        []
                                      |),
                                      [
                                        M.read (| state |);
                                        M.read (| offset |);
                                        M.read (| vec_ref |);
                                        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))
                              ]
                            |)
                          |) 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::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [ M.read (| verifier |); M.read (| elem_ref |) ]
                                |)
                              ]
                            |)
                          |),
                          [
                            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~ _ :=
                          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_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                              "is_value",
                                              []
                                            |),
                                            [
                                              M.match_operator (|
                                                M.alloc (|
                                                  M.call_closure (|
                                                    M.get_associated_function (|
                                                      Ty.apply
                                                        (Ty.path
                                                          "move_abstract_stack::AbstractStack")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                        ],
                                                      "pop",
                                                      []
                                                    |),
                                                    [
                                                      M.SubPointer.get_struct_record_field (|
                                                        M.read (| verifier |),
                                                        "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                        "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/reference_safety/mod.rs:402 "
                                                                                      |)
                                                                                    ]
                                                                                |);
                                                                                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.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) 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",
                                                            []
                                                          |),
                                                          [
                                                            M.alloc (|
                                                              Value.Array
                                                                [
                                                                  M.read (|
                                                                    Value.String
                                                                      "crates/move-bytecode-verifier/src/reference_safety/mod.rs:402 (assert)"
                                                                  |)
                                                                ]
                                                            |);
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "none",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) 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 |) ]
                                                |)
                                              |)
                                            |)
                                          |)))
                                    ]
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) in
                        let~ vec_ref :=
                          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_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                      ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                      "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/reference_safety/mod.rs:403 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              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 (|
                              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::reference_safety::abstract_state::AbstractState",
                                      "vector_op",
                                      []
                                    |),
                                    [
                                      M.read (| state |);
                                      M.read (| offset |);
                                      M.read (| vec_ref |);
                                      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))
                            ]
                          |) 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~ vec_ref :=
                          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_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                      ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                      "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/reference_safety/mod.rs:408 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              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 (|
                              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::reference_safety::abstract_state::AbstractState",
                                      "vector_op",
                                      []
                                    |),
                                    [
                                      M.read (| state |);
                                      M.read (| offset |);
                                      M.read (| vec_ref |);
                                      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))
                            ]
                          |) in
                        let~ element_type :=
                          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::SignatureToken";
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [],
                                    "branch",
                                    []
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_function (|
                                        "move_bytecode_verifier::reference_safety::vec_element_type",
                                        []
                                      |),
                                      [ M.read (| verifier |); 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))
                              ]
                            |)
                          |) 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::reference_safety::ReferenceSafetyAnalysis",
                                    "push",
                                    []
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "value_for",
                                        []
                                      |),
                                      [ M.read (| state |); 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))
                          ]
                        |)));
                    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~ _ :=
                          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_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                              "is_value",
                                              []
                                            |),
                                            [
                                              M.match_operator (|
                                                M.alloc (|
                                                  M.call_closure (|
                                                    M.get_associated_function (|
                                                      Ty.apply
                                                        (Ty.path
                                                          "move_abstract_stack::AbstractStack")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                        ],
                                                      "pop",
                                                      []
                                                    |),
                                                    [
                                                      M.SubPointer.get_struct_record_field (|
                                                        M.read (| verifier |),
                                                        "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                        "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/reference_safety/mod.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.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) 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",
                                                            []
                                                          |),
                                                          [
                                                            M.alloc (|
                                                              Value.Array
                                                                [
                                                                  M.read (|
                                                                    Value.String
                                                                      "crates/move-bytecode-verifier/src/reference_safety/mod.rs:416 (assert)"
                                                                  |)
                                                                ]
                                                            |);
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "none",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) 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 |) ]
                                                |)
                                              |)
                                            |)
                                          |)))
                                    ]
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) in
                        let~ element_type :=
                          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::SignatureToken";
                                        Ty.path "move_binary_format::errors::PartialVMError"
                                      ],
                                    [],
                                    "branch",
                                    []
                                  |),
                                  [
                                    M.call_closure (|
                                      M.get_function (|
                                        "move_bytecode_verifier::reference_safety::vec_element_type",
                                        []
                                      |),
                                      [ M.read (| verifier |); 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))
                              ]
                            |)
                          |) 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::reference_safety::ReferenceSafetyAnalysis",
                                    "push_n",
                                    []
                                  |),
                                  [
                                    M.read (| verifier |);
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path
                                          "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                        "value_for",
                                        []
                                      |),
                                      [ M.read (| state |); 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))
                          ]
                        |)));
                    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~ _ :=
                          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_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                              "is_value",
                                              []
                                            |),
                                            [
                                              M.match_operator (|
                                                M.alloc (|
                                                  M.call_closure (|
                                                    M.get_associated_function (|
                                                      Ty.apply
                                                        (Ty.path
                                                          "move_abstract_stack::AbstractStack")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                        ],
                                                      "pop",
                                                      []
                                                    |),
                                                    [
                                                      M.SubPointer.get_struct_record_field (|
                                                        M.read (| verifier |),
                                                        "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                        "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/reference_safety/mod.rs:423 "
                                                                                      |)
                                                                                    ]
                                                                                |);
                                                                                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.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) 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",
                                                            []
                                                          |),
                                                          [
                                                            M.alloc (|
                                                              Value.Array
                                                                [
                                                                  M.read (|
                                                                    Value.String
                                                                      "crates/move-bytecode-verifier/src/reference_safety/mod.rs:423 (assert)"
                                                                  |)
                                                                ]
                                                            |);
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "none",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) 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 |) ]
                                                |)
                                              |)
                                            |)
                                          |)))
                                    ]
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) 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_bytecode_verifier::reference_safety::abstract_state::AbstractValue",
                                              "is_value",
                                              []
                                            |),
                                            [
                                              M.match_operator (|
                                                M.alloc (|
                                                  M.call_closure (|
                                                    M.get_associated_function (|
                                                      Ty.apply
                                                        (Ty.path
                                                          "move_abstract_stack::AbstractStack")
                                                        []
                                                        [
                                                          Ty.path
                                                            "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                        ],
                                                      "pop",
                                                      []
                                                    |),
                                                    [
                                                      M.SubPointer.get_struct_record_field (|
                                                        M.read (| verifier |),
                                                        "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                        "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/reference_safety/mod.rs:424 "
                                                                                      |)
                                                                                    ]
                                                                                |);
                                                                                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.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) 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",
                                                            []
                                                          |),
                                                          [
                                                            M.alloc (|
                                                              Value.Array
                                                                [
                                                                  M.read (|
                                                                    Value.String
                                                                      "crates/move-bytecode-verifier/src/reference_safety/mod.rs:424 (assert)"
                                                                  |)
                                                                ]
                                                            |);
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.path "core::fmt::rt::Argument",
                                                                  "none",
                                                                  []
                                                                |),
                                                                []
                                                              |)
                                                            |)
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  |) 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 |) ]
                                                |)
                                              |)
                                            |)
                                          |)))
                                    ]
                                  |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                            ]
                          |) in
                        let~ vec_ref :=
                          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_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                      ],
                                    "pop",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| verifier |),
                                      "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                      "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/reference_safety/mod.rs:425 "
                                                                    |)
                                                                  ]
                                                              |);
                                                              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 (|
                              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::reference_safety::abstract_state::AbstractState",
                                      "vector_op",
                                      []
                                    |),
                                    [
                                      M.read (| state |);
                                      M.read (| offset |);
                                      M.read (| vec_ref |);
                                      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))
                            ]
                          |) 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_execute_inner :
    M.IsFunction "move_bytecode_verifier::reference_safety::execute_inner" execute_inner.
  
  Module Impl_move_bytecode_verifier_absint_TransferFunctions_for_move_bytecode_verifier_reference_safety_ReferenceSafetyAnalysis.
    Definition Self : Ty.t :=
      Ty.path "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis".
    
    (*     type State = AbstractState; *)
    Definition _State : Ty.t :=
      Ty.path "move_bytecode_verifier::reference_safety::abstract_state::AbstractState".
    
    (*     type Error = PartialVMError; *)
    Definition _Error : Ty.t := Ty.path "move_binary_format::errors::PartialVMError".
    
    (*
        fn execute(
            &mut self,
            state: &mut Self::State,
            bytecode: &Bytecode,
            index: CodeOffset,
            last_index: CodeOffset,
            meter: &mut (impl Meter + ?Sized),
        ) -> PartialVMResult<()> {
            execute_inner(self, state, bytecode, index, meter)?;
            if index == last_index {
                safe_assert!(self.stack.is_empty());
                *state = state.construct_canonical_state()
            }
            Ok(())
        }
    *)
    Definition execute (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [ impl_Meter__plus___Sized ], [ self; state; bytecode; index; last_index; meter ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let state := M.alloc (| state |) in
          let bytecode := M.alloc (| bytecode |) in
          let index := M.alloc (| index |) in
          let last_index := M.alloc (| last_index |) in
          let meter := M.alloc (| meter |) in
          M.catch_return (|
            ltac:(M.monadic
              (M.read (|
                let~ _ :=
                  M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::ops::try_trait::Try",
                          Ty.apply
                            (Ty.path "core::result::Result")
                            []
                            [ Ty.tuple []; Ty.path "move_binary_format::errors::PartialVMError" ],
                          [],
                          "branch",
                          []
                        |),
                        [
                          M.call_closure (|
                            M.get_function (|
                              "move_bytecode_verifier::reference_safety::execute_inner",
                              [ impl_Meter__plus___Sized ]
                            |),
                            [
                              M.read (| self |);
                              M.read (| state |);
                              M.read (| bytecode |);
                              M.read (| index |);
                              M.read (| meter |)
                            ]
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::ops::control_flow::ControlFlow::Break",
                              0
                            |) in
                          let residual := M.copy (| γ0_0 |) in
                          M.alloc (|
                            M.never_to_any (|
                              M.read (|
                                M.return_ (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::ops::try_trait::FromResidual",
                                      Ty.apply
                                        (Ty.path "core::result::Result")
                                        []
                                        [
                                          Ty.tuple [];
                                          Ty.path "move_binary_format::errors::PartialVMError"
                                        ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::result::Result")
                                          []
                                          [
                                            Ty.path "core::convert::Infallible";
                                            Ty.path "move_binary_format::errors::PartialVMError"
                                          ]
                                      ],
                                      "from_residual",
                                      []
                                    |),
                                    [ M.read (| residual |) ]
                                  |)
                                |)
                              |)
                            |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::ops::control_flow::ControlFlow::Continue",
                              0
                            |) in
                          let val := M.copy (| γ0_0 |) in
                          val))
                    ]
                  |) in
                let~ _ :=
                  M.match_operator (|
                    M.alloc (| Value.Tuple [] |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ :=
                            M.use
                              (M.alloc (|
                                BinOp.eq (| M.read (| index |), M.read (| last_index |) |)
                              |)) 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 (|
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.apply
                                                  (Ty.path "move_abstract_stack::AbstractStack")
                                                  []
                                                  [
                                                    Ty.path
                                                      "move_bytecode_verifier::reference_safety::abstract_state::AbstractValue"
                                                  ],
                                                "is_empty",
                                                []
                                              |),
                                              [
                                                M.SubPointer.get_struct_record_field (|
                                                  M.read (| self |),
                                                  "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis",
                                                  "stack"
                                                |)
                                              ]
                                            |)
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) 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",
                                                              []
                                                            |),
                                                            [
                                                              M.alloc (|
                                                                Value.Array
                                                                  [
                                                                    M.read (|
                                                                      Value.String
                                                                        "crates/move-bytecode-verifier/src/reference_safety/mod.rs:446 (assert)"
                                                                    |)
                                                                  ]
                                                              |);
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.path
                                                                      "core::fmt::rt::Argument",
                                                                    "none",
                                                                    []
                                                                  |),
                                                                  []
                                                                |)
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |)
                                                    |) 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 |) ]
                                                  |)
                                                |)
                                              |)
                                            |)))
                                      ]
                                    |)));
                                fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                              ]
                            |) in
                          M.write (|
                            M.read (| state |),
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path
                                  "move_bytecode_verifier::reference_safety::abstract_state::AbstractState",
                                "construct_canonical_state",
                                []
                              |),
                              [ M.read (| state |) ]
                            |)
                          |)));
                      fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                    ]
                  |) in
                M.alloc (| Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ] |)
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      M.IsTraitInstance
        "move_bytecode_verifier::absint::TransferFunctions"
        Self
        (* Trait polymorphic types *) []
        (* Instance *)
        [
          ("State", InstanceField.Ty _State);
          ("Error", InstanceField.Ty _Error);
          ("execute", InstanceField.Method execute)
        ].
  End Impl_move_bytecode_verifier_absint_TransferFunctions_for_move_bytecode_verifier_reference_safety_ReferenceSafetyAnalysis.
  
  Module Impl_move_bytecode_verifier_absint_AbstractInterpreter_for_move_bytecode_verifier_reference_safety_ReferenceSafetyAnalysis.
    Definition Self : Ty.t :=
      Ty.path "move_bytecode_verifier::reference_safety::ReferenceSafetyAnalysis".
    
    Axiom Implements :
      M.IsTraitInstance
        "move_bytecode_verifier::absint::AbstractInterpreter"
        Self
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_move_bytecode_verifier_absint_AbstractInterpreter_for_move_bytecode_verifier_reference_safety_ReferenceSafetyAnalysis.
End reference_safety.
