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

Module interpreter.
  Module analysis.
    Definition value_EOF_NON_RETURNING_FUNCTION : Value.t :=
      M.run ltac:(M.monadic (M.alloc (| Value.Integer IntegerKind.U8 128 |))).
    
    (*
    pub fn to_analysed(bytecode: Bytecode) -> Bytecode {
        let (bytes, len) = match bytecode {
            Bytecode::LegacyRaw(bytecode) => {
                let len = bytecode.len();
                let mut padded_bytecode = Vec::with_capacity(len + 33);
                padded_bytecode.extend_from_slice(&bytecode);
                padded_bytecode.resize(len + 33, 0);
                (Bytes::from(padded_bytecode), len)
            }
            n => return n,
        };
        let jump_table = analyze(bytes.as_ref());
    
        Bytecode::LegacyAnalyzed(LegacyAnalyzedBytecode::new(bytes, len, jump_table))
    }
    *)
    Definition to_analysed (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ bytecode ] =>
        ltac:(M.monadic
          (let bytecode := M.alloc (| bytecode |) in
          M.catch_return (|
            ltac:(M.monadic
              (M.read (|
                M.match_operator (|
                  M.match_operator (|
                    bytecode,
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "revm_primitives::bytecode::Bytecode::LegacyRaw",
                              0
                            |) in
                          let bytecode := M.copy (| γ0_0 |) in
                          let~ len :=
                            M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "bytes::bytes::Bytes",
                                  "len",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::ops::deref::Deref",
                                      Ty.path "alloy_primitives::bytes_::Bytes",
                                      [],
                                      "deref",
                                      []
                                    |),
                                    [ bytecode ]
                                  |)
                                ]
                              |)
                            |) in
                          let~ padded_bytecode :=
                            M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.apply
                                    (Ty.path "alloc::vec::Vec")
                                    []
                                    [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ],
                                  "with_capacity",
                                  []
                                |),
                                [
                                  BinOp.Wrap.add (|
                                    M.read (| len |),
                                    Value.Integer IntegerKind.Usize 33
                                  |)
                                ]
                              |)
                            |) in
                          let~ _ :=
                            M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.apply
                                    (Ty.path "alloc::vec::Vec")
                                    []
                                    [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ],
                                  "extend_from_slice",
                                  []
                                |),
                                [
                                  padded_bytecode;
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::ops::deref::Deref",
                                      Ty.path "bytes::bytes::Bytes",
                                      [],
                                      "deref",
                                      []
                                    |),
                                    [
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::ops::deref::Deref",
                                          Ty.path "alloy_primitives::bytes_::Bytes",
                                          [],
                                          "deref",
                                          []
                                        |),
                                        [ bytecode ]
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |) in
                          let~ _ :=
                            M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.apply
                                    (Ty.path "alloc::vec::Vec")
                                    []
                                    [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ],
                                  "resize",
                                  []
                                |),
                                [
                                  padded_bytecode;
                                  BinOp.Wrap.add (|
                                    M.read (| len |),
                                    Value.Integer IntegerKind.Usize 33
                                  |);
                                  Value.Integer IntegerKind.U8 0
                                ]
                              |)
                            |) in
                          M.alloc (|
                            Value.Tuple
                              [
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::convert::From",
                                    Ty.path "alloy_primitives::bytes_::Bytes",
                                    [
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [ Ty.path "u8"; Ty.path "alloc::alloc::Global" ]
                                    ],
                                    "from",
                                    []
                                  |),
                                  [ M.read (| padded_bytecode |) ]
                                |);
                                M.read (| len |)
                              ]
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let n := M.copy (| γ |) in
                          M.alloc (|
                            M.never_to_any (| M.read (| M.return_ (| M.read (| n |) |) |) |)
                          |)))
                    ]
                  |),
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                        let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                        let bytes := M.copy (| γ0_0 |) in
                        let len := M.copy (| γ0_1 |) in
                        let~ jump_table :=
                          M.alloc (|
                            M.call_closure (|
                              M.get_function (|
                                "revm_interpreter::interpreter::analysis::analyze",
                                []
                              |),
                              [
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::convert::AsRef",
                                    Ty.path "alloy_primitives::bytes_::Bytes",
                                    [ Ty.apply (Ty.path "slice") [] [ Ty.path "u8" ] ],
                                    "as_ref",
                                    []
                                  |),
                                  [ bytes ]
                                |)
                              ]
                            |)
                          |) in
                        M.alloc (|
                          Value.StructTuple
                            "revm_primitives::bytecode::Bytecode::LegacyAnalyzed"
                            [
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path
                                    "revm_primitives::bytecode::legacy::LegacyAnalyzedBytecode",
                                  "new",
                                  []
                                |),
                                [ M.read (| bytes |); M.read (| len |); M.read (| jump_table |) ]
                              |)
                            ]
                        |)))
                  ]
                |)
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Function_to_analysed :
      M.IsFunction "revm_interpreter::interpreter::analysis::to_analysed" to_analysed.
    
    (*
    fn analyze(code: &[u8]) -> JumpTable {
        let mut jumps: BitVec<u8> = bitvec![u8, Lsb0; 0; code.len()];
    
        let range = code.as_ptr_range();
        let start = range.start;
        let mut iterator = start;
        let end = range.end;
        while iterator < end {
            let opcode = unsafe { *iterator };
            if opcode::JUMPDEST == opcode {
                // SAFETY: jumps are max length of the code
                unsafe { jumps.set_unchecked(iterator.offset_from(start) as usize, true) }
                iterator = unsafe { iterator.offset(1) };
            } else {
                let push_offset = opcode.wrapping_sub(opcode::PUSH1);
                if push_offset < 32 {
                    // SAFETY: iterator access range is checked in the while loop
                    iterator = unsafe { iterator.offset((push_offset + 2) as isize) };
                } else {
                    // SAFETY: iterator access range is checked in the while loop
                    iterator = unsafe { iterator.offset(1) };
                }
            }
        }
    
        JumpTable(Arc::new(jumps))
    }
    *)
    Definition analyze (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ code ] =>
        ltac:(M.monadic
          (let code := M.alloc (| code |) in
          M.read (|
            let~ jumps :=
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.apply
                      (Ty.path "bitvec::vec::BitVec")
                      []
                      [ Ty.path "u8"; Ty.path "bitvec::order::Lsb0" ],
                    "repeat",
                    []
                  |),
                  [
                    BinOp.ne (| Value.Integer IntegerKind.I32 0, Value.Integer IntegerKind.I32 0 |);
                    M.call_closure (|
                      M.get_associated_function (|
                        Ty.apply (Ty.path "slice") [] [ Ty.path "u8" ],
                        "len",
                        []
                      |),
                      [ M.read (| code |) ]
                    |)
                  ]
                |)
              |) in
            let~ range :=
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.apply (Ty.path "slice") [] [ Ty.path "u8" ],
                    "as_ptr_range",
                    []
                  |),
                  [ M.read (| code |) ]
                |)
              |) in
            let~ start :=
              M.copy (|
                M.SubPointer.get_struct_record_field (| range, "core::ops::range::Range", "start" |)
              |) in
            let~ iterator := M.copy (| start |) in
            let~ end_ :=
              M.copy (|
                M.SubPointer.get_struct_record_field (| range, "core::ops::range::Range", "end" |)
              |) in
            let~ _ :=
              M.loop (|
                ltac:(M.monadic
                  (M.match_operator (|
                    M.alloc (| Value.Tuple [] |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ :=
                            M.use
                              (M.alloc (|
                                BinOp.lt (| M.read (| iterator |), M.read (| end_ |) |)
                              |)) in
                          let _ :=
                            M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                          let~ opcode := M.copy (| M.read (| iterator |) |) in
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ :=
                                    M.use
                                      (M.alloc (|
                                        BinOp.eq (|
                                          M.read (|
                                            M.get_constant (|
                                              "revm_interpreter::opcode::JUMPDEST"
                                            |)
                                          |),
                                          M.read (| opcode |)
                                        |)
                                      |)) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ |),
                                      Value.Bool true
                                    |) in
                                  let~ _ :=
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.apply
                                            (Ty.path "bitvec::slice::BitSlice")
                                            []
                                            [ Ty.path "u8"; Ty.path "bitvec::order::Lsb0" ],
                                          "set_unchecked",
                                          []
                                        |),
                                        [
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::ops::deref::DerefMut",
                                              Ty.apply
                                                (Ty.path "bitvec::vec::BitVec")
                                                []
                                                [ Ty.path "u8"; Ty.path "bitvec::order::Lsb0" ],
                                              [],
                                              "deref_mut",
                                              []
                                            |),
                                            [ jumps ]
                                          |);
                                          M.rust_cast
                                            (M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.apply (Ty.path "*const") [] [ Ty.path "u8" ],
                                                "offset_from",
                                                []
                                              |),
                                              [ M.read (| iterator |); M.read (| start |) ]
                                            |));
                                          Value.Bool true
                                        ]
                                      |)
                                    |) in
                                  let~ _ :=
                                    M.write (|
                                      iterator,
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.apply (Ty.path "*const") [] [ Ty.path "u8" ],
                                          "offset",
                                          []
                                        |),
                                        [ M.read (| iterator |); Value.Integer IntegerKind.Isize 1 ]
                                      |)
                                    |) in
                                  M.alloc (| Value.Tuple [] |)));
                              fun γ =>
                                ltac:(M.monadic
                                  (let~ push_offset :=
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.path "u8",
                                          "wrapping_sub",
                                          []
                                        |),
                                        [
                                          M.read (| opcode |);
                                          M.read (|
                                            M.get_constant (| "revm_interpreter::opcode::PUSH1" |)
                                          |)
                                        ]
                                      |)
                                    |) in
                                  M.match_operator (|
                                    M.alloc (| Value.Tuple [] |),
                                    [
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let γ :=
                                            M.use
                                              (M.alloc (|
                                                BinOp.lt (|
                                                  M.read (| push_offset |),
                                                  Value.Integer IntegerKind.U8 32
                                                |)
                                              |)) in
                                          let _ :=
                                            M.is_constant_or_break_match (|
                                              M.read (| γ |),
                                              Value.Bool true
                                            |) in
                                          let~ _ :=
                                            M.write (|
                                              iterator,
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.apply (Ty.path "*const") [] [ Ty.path "u8" ],
                                                  "offset",
                                                  []
                                                |),
                                                [
                                                  M.read (| iterator |);
                                                  M.rust_cast
                                                    (BinOp.Wrap.add (|
                                                      M.read (| push_offset |),
                                                      Value.Integer IntegerKind.U8 2
                                                    |))
                                                ]
                                              |)
                                            |) in
                                          M.alloc (| Value.Tuple [] |)));
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let~ _ :=
                                            M.write (|
                                              iterator,
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.apply (Ty.path "*const") [] [ Ty.path "u8" ],
                                                  "offset",
                                                  []
                                                |),
                                                [
                                                  M.read (| iterator |);
                                                  Value.Integer IntegerKind.Isize 1
                                                ]
                                              |)
                                            |) in
                                          M.alloc (| Value.Tuple [] |)))
                                    ]
                                  |)))
                            ]
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (M.alloc (|
                            M.never_to_any (|
                              M.read (|
                                let~ _ :=
                                  M.alloc (| M.never_to_any (| M.read (| M.break (||) |) |) |) in
                                M.alloc (| Value.Tuple [] |)
                              |)
                            |)
                          |)))
                    ]
                  |)))
              |) in
            M.alloc (|
              Value.StructTuple
                "revm_primitives::bytecode::legacy::jump_map::JumpTable"
                [
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.apply
                        (Ty.path "alloc::sync::Arc")
                        []
                        [
                          Ty.apply
                            (Ty.path "bitvec::vec::BitVec")
                            []
                            [ Ty.path "u8"; Ty.path "bitvec::order::Lsb0" ];
                          Ty.path "alloc::alloc::Global"
                        ],
                      "new",
                      []
                    |),
                    [ M.read (| jumps |) ]
                  |)
                ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Function_analyze :
      M.IsFunction "revm_interpreter::interpreter::analysis::analyze" analyze.
    
    (*
    pub fn validate_raw_eof(bytecode: Bytes) -> Result<Eof, EofError> {
        let eof = Eof::decode(bytecode)?;
        validate_eof(&eof)?;
        Ok(eof)
    }
    *)
    Definition validate_raw_eof (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ bytecode ] =>
        ltac:(M.monadic
          (let bytecode := M.alloc (| bytecode |) in
          M.catch_return (|
            ltac:(M.monadic
              (M.read (|
                let~ eof :=
                  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 "revm_primitives::bytecode::eof::Eof";
                                Ty.path "revm_primitives::bytecode::eof::EofDecodeError"
                              ],
                            [],
                            "branch",
                            []
                          |),
                          [
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "revm_primitives::bytecode::eof::Eof",
                                "decode",
                                []
                              |),
                              [ M.read (| bytecode |) ]
                            |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::ops::control_flow::ControlFlow::Break",
                                0
                              |) in
                            let residual := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    M.call_closure (|
                                      M.get_trait_method (|
                                        "core::ops::try_trait::FromResidual",
                                        Ty.apply
                                          (Ty.path "core::result::Result")
                                          []
                                          [
                                            Ty.path "revm_primitives::bytecode::eof::Eof";
                                            Ty.path
                                              "revm_interpreter::interpreter::analysis::EofError"
                                          ],
                                        [
                                          Ty.apply
                                            (Ty.path "core::result::Result")
                                            []
                                            [
                                              Ty.path "core::convert::Infallible";
                                              Ty.path
                                                "revm_primitives::bytecode::eof::EofDecodeError"
                                            ]
                                        ],
                                        "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 "revm_interpreter::interpreter::analysis::EofError"
                            ],
                          [],
                          "branch",
                          []
                        |),
                        [
                          M.call_closure (|
                            M.get_function (|
                              "revm_interpreter::interpreter::analysis::validate_eof",
                              []
                            |),
                            [ eof ]
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ0_0 :=
                            M.SubPointer.get_struct_tuple_field (|
                              γ,
                              "core::ops::control_flow::ControlFlow::Break",
                              0
                            |) in
                          let residual := M.copy (| γ0_0 |) in
                          M.alloc (|
                            M.never_to_any (|
                              M.read (|
                                M.return_ (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::ops::try_trait::FromResidual",
                                      Ty.apply
                                        (Ty.path "core::result::Result")
                                        []
                                        [
                                          Ty.path "revm_primitives::bytecode::eof::Eof";
                                          Ty.path
                                            "revm_interpreter::interpreter::analysis::EofError"
                                        ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::result::Result")
                                          []
                                          [
                                            Ty.path "core::convert::Infallible";
                                            Ty.path
                                              "revm_interpreter::interpreter::analysis::EofError"
                                          ]
                                      ],
                                      "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" [ M.read (| eof |) ] |)
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Function_validate_raw_eof :
      M.IsFunction "revm_interpreter::interpreter::analysis::validate_raw_eof" validate_raw_eof.
    
    (*
    pub fn validate_eof(eof: &Eof) -> Result<(), EofError> {
        // clone is cheap as it is Bytes and a header.
        let mut queue = vec![eof.clone()];
    
        while let Some(eof) = queue.pop() {
            // iterate over types
            validate_eof_codes(&eof)?;
            // iterate over containers, convert them to Eof and add to analyze_eof
            for container in eof.body.container_section {
                queue.push(Eof::decode(container)?);
            }
        }
    
        // Eof is valid
        Ok(())
    }
    *)
    Definition validate_eof (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ eof ] =>
        ltac:(M.monadic
          (let eof := M.alloc (| eof |) in
          M.catch_return (|
            ltac:(M.monadic
              (M.read (|
                let~ queue :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_associated_function (|
                        Ty.apply
                          (Ty.path "slice")
                          []
                          [ Ty.path "revm_primitives::bytecode::eof::Eof" ],
                        "into_vec",
                        [ Ty.path "alloc::alloc::Global" ]
                      |),
                      [
                        M.read (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.apply
                                (Ty.path "alloc::boxed::Box")
                                []
                                [
                                  Ty.apply
                                    (Ty.path "array")
                                    [ Value.Integer IntegerKind.Usize 1 ]
                                    [ Ty.path "revm_primitives::bytecode::eof::Eof" ];
                                  Ty.path "alloc::alloc::Global"
                                ],
                              "new",
                              []
                            |),
                            [
                              M.alloc (|
                                Value.Array
                                  [
                                    M.call_closure (|
                                      M.get_trait_method (|
                                        "core::clone::Clone",
                                        Ty.path "revm_primitives::bytecode::eof::Eof",
                                        [],
                                        "clone",
                                        []
                                      |),
                                      [ M.read (| eof |) ]
                                    |)
                                  ]
                              |)
                            ]
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.loop (|
                    ltac:(M.monadic
                      (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 "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "revm_primitives::bytecode::eof::Eof";
                                          Ty.path "alloc::alloc::Global"
                                        ],
                                      "pop",
                                      []
                                    |),
                                    [ queue ]
                                  |)
                                |) in
                              let γ0_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ,
                                  "core::option::Option::Some",
                                  0
                                |) in
                              let eof := M.copy (| γ0_0 |) in
                              let~ _ :=
                                M.match_operator (|
                                  M.alloc (|
                                    M.call_closure (|
                                      M.get_trait_method (|
                                        "core::ops::try_trait::Try",
                                        Ty.apply
                                          (Ty.path "core::result::Result")
                                          []
                                          [
                                            Ty.tuple [];
                                            Ty.path
                                              "revm_interpreter::interpreter::analysis::EofValidationError"
                                          ],
                                        [],
                                        "branch",
                                        []
                                      |),
                                      [
                                        M.call_closure (|
                                          M.get_function (|
                                            "revm_interpreter::interpreter::analysis::validate_eof_codes",
                                            []
                                          |),
                                          [ eof ]
                                        |)
                                      ]
                                    |)
                                  |),
                                  [
                                    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
                                                          "revm_interpreter::interpreter::analysis::EofError"
                                                      ],
                                                    [
                                                      Ty.apply
                                                        (Ty.path "core::result::Result")
                                                        []
                                                        [
                                                          Ty.path "core::convert::Infallible";
                                                          Ty.path
                                                            "revm_interpreter::interpreter::analysis::EofValidationError"
                                                        ]
                                                    ],
                                                    "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.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 "alloy_primitives::bytes_::Bytes";
                                            Ty.path "alloc::alloc::Global"
                                          ],
                                        [],
                                        "into_iter",
                                        []
                                      |),
                                      [
                                        M.read (|
                                          M.SubPointer.get_struct_record_field (|
                                            M.SubPointer.get_struct_record_field (|
                                              eof,
                                              "revm_primitives::bytecode::eof::Eof",
                                              "body"
                                            |),
                                            "revm_primitives::bytecode::eof::body::EofBody",
                                            "container_section"
                                          |)
                                        |)
                                      ]
                                    |)
                                  |),
                                  [
                                    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 "alloy_primitives::bytes_::Bytes";
                                                          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 container := M.copy (| γ0_0 |) in
                                                      let~ _ :=
                                                        M.alloc (|
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.apply
                                                                (Ty.path "alloc::vec::Vec")
                                                                []
                                                                [
                                                                  Ty.path
                                                                    "revm_primitives::bytecode::eof::Eof";
                                                                  Ty.path "alloc::alloc::Global"
                                                                ],
                                                              "push",
                                                              []
                                                            |),
                                                            [
                                                              queue;
                                                              M.read (|
                                                                M.match_operator (|
                                                                  M.alloc (|
                                                                    M.call_closure (|
                                                                      M.get_trait_method (|
                                                                        "core::ops::try_trait::Try",
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::result::Result")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "revm_primitives::bytecode::eof::Eof";
                                                                            Ty.path
                                                                              "revm_primitives::bytecode::eof::EofDecodeError"
                                                                          ],
                                                                        [],
                                                                        "branch",
                                                                        []
                                                                      |),
                                                                      [
                                                                        M.call_closure (|
                                                                          M.get_associated_function (|
                                                                            Ty.path
                                                                              "revm_primitives::bytecode::eof::Eof",
                                                                            "decode",
                                                                            []
                                                                          |),
                                                                          [ M.read (| container |) ]
                                                                        |)
                                                                      ]
                                                                    |)
                                                                  |),
                                                                  [
                                                                    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
                                                                                          "revm_interpreter::interpreter::analysis::EofError"
                                                                                      ],
                                                                                    [
                                                                                      Ty.apply
                                                                                        (Ty.path
                                                                                          "core::result::Result")
                                                                                        []
                                                                                        [
                                                                                          Ty.path
                                                                                            "core::convert::Infallible";
                                                                                          Ty.path
                                                                                            "revm_primitives::bytecode::eof::EofDecodeError"
                                                                                        ]
                                                                                    ],
                                                                                    "from_residual",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    M.read (|
                                                                                      residual
                                                                                    |)
                                                                                  ]
                                                                                |)
                                                                              |)
                                                                            |)
                                                                          |)
                                                                        |)));
                                                                    fun γ =>
                                                                      ltac:(M.monadic
                                                                        (let γ0_0 :=
                                                                          M.SubPointer.get_struct_tuple_field (|
                                                                            γ,
                                                                            "core::ops::control_flow::ControlFlow::Continue",
                                                                            0
                                                                          |) in
                                                                        let val :=
                                                                          M.copy (| γ0_0 |) in
                                                                        val))
                                                                  ]
                                                                |)
                                                              |)
                                                            ]
                                                          |)
                                                        |) in
                                                      M.alloc (| Value.Tuple [] |)))
                                                ]
                                              |) in
                                            M.alloc (| Value.Tuple [] |)))
                                        |)))
                                  ]
                                |))));
                          fun γ =>
                            ltac:(M.monadic
                              (M.alloc (|
                                M.never_to_any (|
                                  M.read (|
                                    let~ _ :=
                                      M.alloc (|
                                        M.never_to_any (| M.read (| M.break (||) |) |)
                                      |) in
                                    M.alloc (| Value.Tuple [] |)
                                  |)
                                |)
                              |)))
                        ]
                      |)))
                  |) in
                M.alloc (| Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ] |)
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Function_validate_eof :
      M.IsFunction "revm_interpreter::interpreter::analysis::validate_eof" validate_eof.
    
    (*
    pub fn validate_eof_codes(eof: &Eof) -> Result<(), EofValidationError> {
        let mut queued_codes = vec![false; eof.body.code_section.len()];
        if eof.body.code_section.len() != eof.body.types_section.len() {
            return Err(EofValidationError::InvalidTypesSection);
        }
    
        if eof.body.code_section.is_empty() {
            // no code sections. This should be already checked in decode.
            return Err(EofValidationError::NoCodeSections);
        }
        // first section is default one.
        queued_codes[0] = true;
    
        // the first code section must have a type signature
        // (0, 0x80, max_stack_height) (0 inputs non-returning function)
        let first_types = &eof.body.types_section[0];
        if first_types.inputs != 0 || first_types.outputs != EOF_NON_RETURNING_FUNCTION {
            return Err(EofValidationError::InvalidTypesSection);
        }
    
        // start validation from code section 0.
        let mut queue = vec![0];
        while let Some(index) = queue.pop() {
            let code = &eof.body.code_section[index];
            let accessed_codes = validate_eof_code(
                code,
                eof.header.data_size as usize,
                index,
                eof.body.container_section.len(),
                &eof.body.types_section,
            )?;
    
            // queue accessed codes.
            accessed_codes.into_iter().for_each(|i| {
                if !queued_codes[i] {
                    queued_codes[i] = true;
                    queue.push(i);
                }
            });
        }
        // iterate over accessed codes and check if all are accessed.
        if queued_codes.into_iter().any(|x| !x) {
            return Err(EofValidationError::CodeSectionNotAccessed);
        }
    
        Ok(())
    }
    *)
    Definition validate_eof_codes (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ eof ] =>
        ltac:(M.monadic
          (let eof := M.alloc (| eof |) in
          M.catch_return (|
            ltac:(M.monadic
              (M.read (|
                let~ queued_codes :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_function (| "alloc::vec::from_elem", [ Ty.path "bool" ] |),
                      [
                        Value.Bool false;
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.apply
                              (Ty.path "alloc::vec::Vec")
                              []
                              [
                                Ty.path "alloy_primitives::bytes_::Bytes";
                                Ty.path "alloc::alloc::Global"
                              ],
                            "len",
                            []
                          |),
                          [
                            M.SubPointer.get_struct_record_field (|
                              M.SubPointer.get_struct_record_field (|
                                M.read (| eof |),
                                "revm_primitives::bytecode::eof::Eof",
                                "body"
                              |),
                              "revm_primitives::bytecode::eof::body::EofBody",
                              "code_section"
                            |)
                          ]
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.match_operator (|
                    M.alloc (| Value.Tuple [] |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ :=
                            M.use
                              (M.alloc (|
                                BinOp.ne (|
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "alloy_primitives::bytes_::Bytes";
                                          Ty.path "alloc::alloc::Global"
                                        ],
                                      "len",
                                      []
                                    |),
                                    [
                                      M.SubPointer.get_struct_record_field (|
                                        M.SubPointer.get_struct_record_field (|
                                          M.read (| eof |),
                                          "revm_primitives::bytecode::eof::Eof",
                                          "body"
                                        |),
                                        "revm_primitives::bytecode::eof::body::EofBody",
                                        "code_section"
                                      |)
                                    ]
                                  |),
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path
                                            "revm_primitives::bytecode::eof::types_section::TypesSection";
                                          Ty.path "alloc::alloc::Global"
                                        ],
                                      "len",
                                      []
                                    |),
                                    [
                                      M.SubPointer.get_struct_record_field (|
                                        M.SubPointer.get_struct_record_field (|
                                          M.read (| eof |),
                                          "revm_primitives::bytecode::eof::Eof",
                                          "body"
                                        |),
                                        "revm_primitives::bytecode::eof::body::EofBody",
                                        "types_section"
                                      |)
                                    ]
                                  |)
                                |)
                              |)) in
                          let _ :=
                            M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                          M.alloc (|
                            M.never_to_any (|
                              M.read (|
                                M.return_ (|
                                  Value.StructTuple
                                    "core::result::Result::Err"
                                    [
                                      Value.StructTuple
                                        "revm_interpreter::interpreter::analysis::EofValidationError::InvalidTypesSection"
                                        []
                                    ]
                                |)
                              |)
                            |)
                          |)));
                      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 (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "alloc::vec::Vec")
                                      []
                                      [
                                        Ty.path "alloy_primitives::bytes_::Bytes";
                                        Ty.path "alloc::alloc::Global"
                                      ],
                                    "is_empty",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.SubPointer.get_struct_record_field (|
                                        M.read (| eof |),
                                        "revm_primitives::bytecode::eof::Eof",
                                        "body"
                                      |),
                                      "revm_primitives::bytecode::eof::body::EofBody",
                                      "code_section"
                                    |)
                                  ]
                                |)
                              |)) in
                          let _ :=
                            M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                          M.alloc (|
                            M.never_to_any (|
                              M.read (|
                                M.return_ (|
                                  Value.StructTuple
                                    "core::result::Result::Err"
                                    [
                                      Value.StructTuple
                                        "revm_interpreter::interpreter::analysis::EofValidationError::NoCodeSections"
                                        []
                                    ]
                                |)
                              |)
                            |)
                          |)));
                      fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                    ]
                  |) in
                let~ _ :=
                  M.write (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "core::ops::index::IndexMut",
                        Ty.apply
                          (Ty.path "alloc::vec::Vec")
                          []
                          [ Ty.path "bool"; Ty.path "alloc::alloc::Global" ],
                        [ Ty.path "usize" ],
                        "index_mut",
                        []
                      |),
                      [ queued_codes; Value.Integer IntegerKind.Usize 0 ]
                    |),
                    Value.Bool true
                  |) in
                let~ first_types :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "core::ops::index::Index",
                        Ty.apply
                          (Ty.path "alloc::vec::Vec")
                          []
                          [
                            Ty.path "revm_primitives::bytecode::eof::types_section::TypesSection";
                            Ty.path "alloc::alloc::Global"
                          ],
                        [ Ty.path "usize" ],
                        "index",
                        []
                      |),
                      [
                        M.SubPointer.get_struct_record_field (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| eof |),
                            "revm_primitives::bytecode::eof::Eof",
                            "body"
                          |),
                          "revm_primitives::bytecode::eof::body::EofBody",
                          "types_section"
                        |);
                        Value.Integer IntegerKind.Usize 0
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.match_operator (|
                    M.alloc (| Value.Tuple [] |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ :=
                            M.use
                              (M.alloc (|
                                LogicalOp.or (|
                                  BinOp.ne (|
                                    M.read (|
                                      M.SubPointer.get_struct_record_field (|
                                        M.read (| first_types |),
                                        "revm_primitives::bytecode::eof::types_section::TypesSection",
                                        "inputs"
                                      |)
                                    |),
                                    Value.Integer IntegerKind.U8 0
                                  |),
                                  ltac:(M.monadic
                                    (BinOp.ne (|
                                      M.read (|
                                        M.SubPointer.get_struct_record_field (|
                                          M.read (| first_types |),
                                          "revm_primitives::bytecode::eof::types_section::TypesSection",
                                          "outputs"
                                        |)
                                      |),
                                      M.read (|
                                        M.get_constant (|
                                          "revm_interpreter::interpreter::analysis::EOF_NON_RETURNING_FUNCTION"
                                        |)
                                      |)
                                    |)))
                                |)
                              |)) in
                          let _ :=
                            M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                          M.alloc (|
                            M.never_to_any (|
                              M.read (|
                                M.return_ (|
                                  Value.StructTuple
                                    "core::result::Result::Err"
                                    [
                                      Value.StructTuple
                                        "revm_interpreter::interpreter::analysis::EofValidationError::InvalidTypesSection"
                                        []
                                    ]
                                |)
                              |)
                            |)
                          |)));
                      fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                    ]
                  |) in
                let~ queue :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_associated_function (|
                        Ty.apply (Ty.path "slice") [] [ Ty.path "usize" ],
                        "into_vec",
                        [ Ty.path "alloc::alloc::Global" ]
                      |),
                      [
                        M.read (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.apply
                                (Ty.path "alloc::boxed::Box")
                                []
                                [
                                  Ty.apply
                                    (Ty.path "array")
                                    [ Value.Integer IntegerKind.Usize 1 ]
                                    [ Ty.path "usize" ];
                                  Ty.path "alloc::alloc::Global"
                                ],
                              "new",
                              []
                            |),
                            [ M.alloc (| Value.Array [ Value.Integer IntegerKind.Usize 0 ] |) ]
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.loop (|
                    ltac:(M.monadic
                      (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 "alloc::vec::Vec")
                                        []
                                        [ Ty.path "usize"; Ty.path "alloc::alloc::Global" ],
                                      "pop",
                                      []
                                    |),
                                    [ queue ]
                                  |)
                                |) in
                              let γ0_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ,
                                  "core::option::Option::Some",
                                  0
                                |) in
                              let index := M.copy (| γ0_0 |) in
                              let~ code :=
                                M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::ops::index::Index",
                                      Ty.apply
                                        (Ty.path "alloc::vec::Vec")
                                        []
                                        [
                                          Ty.path "alloy_primitives::bytes_::Bytes";
                                          Ty.path "alloc::alloc::Global"
                                        ],
                                      [ Ty.path "usize" ],
                                      "index",
                                      []
                                    |),
                                    [
                                      M.SubPointer.get_struct_record_field (|
                                        M.SubPointer.get_struct_record_field (|
                                          M.read (| eof |),
                                          "revm_primitives::bytecode::eof::Eof",
                                          "body"
                                        |),
                                        "revm_primitives::bytecode::eof::body::EofBody",
                                        "code_section"
                                      |);
                                      M.read (| index |)
                                    ]
                                  |)
                                |) in
                              let~ accessed_codes :=
                                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 "std::collections::hash::set::HashSet")
                                                []
                                                [
                                                  Ty.path "usize";
                                                  Ty.path "std::hash::random::RandomState"
                                                ];
                                              Ty.path
                                                "revm_interpreter::interpreter::analysis::EofValidationError"
                                            ],
                                          [],
                                          "branch",
                                          []
                                        |),
                                        [
                                          M.call_closure (|
                                            M.get_function (|
                                              "revm_interpreter::interpreter::analysis::validate_eof_code",
                                              []
                                            |),
                                            [
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::ops::deref::Deref",
                                                  Ty.path "bytes::bytes::Bytes",
                                                  [],
                                                  "deref",
                                                  []
                                                |),
                                                [
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::ops::deref::Deref",
                                                      Ty.path "alloy_primitives::bytes_::Bytes",
                                                      [],
                                                      "deref",
                                                      []
                                                    |),
                                                    [ M.read (| code |) ]
                                                  |)
                                                ]
                                              |);
                                              M.rust_cast
                                                (M.read (|
                                                  M.SubPointer.get_struct_record_field (|
                                                    M.SubPointer.get_struct_record_field (|
                                                      M.read (| eof |),
                                                      "revm_primitives::bytecode::eof::Eof",
                                                      "header"
                                                    |),
                                                    "revm_primitives::bytecode::eof::header::EofHeader",
                                                    "data_size"
                                                  |)
                                                |));
                                              M.read (| index |);
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.apply
                                                    (Ty.path "alloc::vec::Vec")
                                                    []
                                                    [
                                                      Ty.path "alloy_primitives::bytes_::Bytes";
                                                      Ty.path "alloc::alloc::Global"
                                                    ],
                                                  "len",
                                                  []
                                                |),
                                                [
                                                  M.SubPointer.get_struct_record_field (|
                                                    M.SubPointer.get_struct_record_field (|
                                                      M.read (| eof |),
                                                      "revm_primitives::bytecode::eof::Eof",
                                                      "body"
                                                    |),
                                                    "revm_primitives::bytecode::eof::body::EofBody",
                                                    "container_section"
                                                  |)
                                                ]
                                              |);
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::ops::deref::Deref",
                                                  Ty.apply
                                                    (Ty.path "alloc::vec::Vec")
                                                    []
                                                    [
                                                      Ty.path
                                                        "revm_primitives::bytecode::eof::types_section::TypesSection";
                                                      Ty.path "alloc::alloc::Global"
                                                    ],
                                                  [],
                                                  "deref",
                                                  []
                                                |),
                                                [
                                                  M.SubPointer.get_struct_record_field (|
                                                    M.SubPointer.get_struct_record_field (|
                                                      M.read (| eof |),
                                                      "revm_primitives::bytecode::eof::Eof",
                                                      "body"
                                                    |),
                                                    "revm_primitives::bytecode::eof::body::EofBody",
                                                    "types_section"
                                                  |)
                                                ]
                                              |)
                                            ]
                                          |)
                                        ]
                                      |)
                                    |),
                                    [
                                      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
                                                            "revm_interpreter::interpreter::analysis::EofValidationError"
                                                        ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::result::Result")
                                                          []
                                                          [
                                                            Ty.path "core::convert::Infallible";
                                                            Ty.path
                                                              "revm_interpreter::interpreter::analysis::EofValidationError"
                                                          ]
                                                      ],
                                                      "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.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::iter::traits::iterator::Iterator",
                                      Ty.apply
                                        (Ty.path "std::collections::hash::set::IntoIter")
                                        []
                                        [ Ty.path "usize" ],
                                      [],
                                      "for_each",
                                      [ Ty.function [ Ty.tuple [ Ty.path "usize" ] ] (Ty.tuple []) ]
                                    |),
                                    [
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::iter::traits::collect::IntoIterator",
                                          Ty.apply
                                            (Ty.path "std::collections::hash::set::HashSet")
                                            []
                                            [
                                              Ty.path "usize";
                                              Ty.path "std::hash::random::RandomState"
                                            ],
                                          [],
                                          "into_iter",
                                          []
                                        |),
                                        [ M.read (| accessed_codes |) ]
                                      |);
                                      M.closure
                                        (fun γ =>
                                          ltac:(M.monadic
                                            match γ with
                                            | [ α0 ] =>
                                              ltac:(M.monadic
                                                (M.match_operator (|
                                                  M.alloc (| α0 |),
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let i := M.copy (| γ |) in
                                                        M.read (|
                                                          M.match_operator (|
                                                            M.alloc (| Value.Tuple [] |),
                                                            [
                                                              fun γ =>
                                                                ltac:(M.monadic
                                                                  (let γ :=
                                                                    M.use
                                                                      (M.alloc (|
                                                                        UnOp.not (|
                                                                          M.read (|
                                                                            M.call_closure (|
                                                                              M.get_trait_method (|
                                                                                "core::ops::index::Index",
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "alloc::vec::Vec")
                                                                                  []
                                                                                  [
                                                                                    Ty.path "bool";
                                                                                    Ty.path
                                                                                      "alloc::alloc::Global"
                                                                                  ],
                                                                                [ Ty.path "usize" ],
                                                                                "index",
                                                                                []
                                                                              |),
                                                                              [
                                                                                queued_codes;
                                                                                M.read (| i |)
                                                                              ]
                                                                            |)
                                                                          |)
                                                                        |)
                                                                      |)) in
                                                                  let _ :=
                                                                    M.is_constant_or_break_match (|
                                                                      M.read (| γ |),
                                                                      Value.Bool true
                                                                    |) in
                                                                  let~ _ :=
                                                                    M.write (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::ops::index::IndexMut",
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "alloc::vec::Vec")
                                                                            []
                                                                            [
                                                                              Ty.path "bool";
                                                                              Ty.path
                                                                                "alloc::alloc::Global"
                                                                            ],
                                                                          [ Ty.path "usize" ],
                                                                          "index_mut",
                                                                          []
                                                                        |),
                                                                        [
                                                                          queued_codes;
                                                                          M.read (| i |)
                                                                        ]
                                                                      |),
                                                                      Value.Bool true
                                                                    |) in
                                                                  let~ _ :=
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_associated_function (|
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "alloc::vec::Vec")
                                                                            []
                                                                            [
                                                                              Ty.path "usize";
                                                                              Ty.path
                                                                                "alloc::alloc::Global"
                                                                            ],
                                                                          "push",
                                                                          []
                                                                        |),
                                                                        [ queue; M.read (| i |) ]
                                                                      |)
                                                                    |) in
                                                                  M.alloc (| Value.Tuple [] |)));
                                                              fun γ =>
                                                                ltac:(M.monadic
                                                                  (M.alloc (| Value.Tuple [] |)))
                                                            ]
                                                          |)
                                                        |)))
                                                  ]
                                                |)))
                                            | _ => M.impossible "wrong number of arguments"
                                            end))
                                    ]
                                  |)
                                |) in
                              M.alloc (| Value.Tuple [] |)));
                          fun γ =>
                            ltac:(M.monadic
                              (M.alloc (|
                                M.never_to_any (|
                                  M.read (|
                                    let~ _ :=
                                      M.alloc (|
                                        M.never_to_any (| M.read (| M.break (||) |) |)
                                      |) in
                                    M.alloc (| Value.Tuple [] |)
                                  |)
                                |)
                              |)))
                        ]
                      |)))
                  |) in
                let~ _ :=
                  M.match_operator (|
                    M.alloc (| Value.Tuple [] |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ :=
                            M.use
                              (M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::iter::traits::iterator::Iterator",
                                    Ty.apply
                                      (Ty.path "alloc::vec::into_iter::IntoIter")
                                      []
                                      [ Ty.path "bool"; Ty.path "alloc::alloc::Global" ],
                                    [],
                                    "any",
                                    [ Ty.function [ Ty.tuple [ Ty.path "bool" ] ] (Ty.path "bool") ]
                                  |),
                                  [
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::iter::traits::collect::IntoIterator",
                                          Ty.apply
                                            (Ty.path "alloc::vec::Vec")
                                            []
                                            [ Ty.path "bool"; Ty.path "alloc::alloc::Global" ],
                                          [],
                                          "into_iter",
                                          []
                                        |),
                                        [ M.read (| queued_codes |) ]
                                      |)
                                    |);
                                    M.closure
                                      (fun γ =>
                                        ltac:(M.monadic
                                          match γ with
                                          | [ α0 ] =>
                                            ltac:(M.monadic
                                              (M.match_operator (|
                                                M.alloc (| α0 |),
                                                [
                                                  fun γ =>
                                                    ltac:(M.monadic
                                                      (let x := M.copy (| γ |) in
                                                      UnOp.not (| M.read (| x |) |)))
                                                ]
                                              |)))
                                          | _ => M.impossible "wrong number of arguments"
                                          end))
                                  ]
                                |)
                              |)) in
                          let _ :=
                            M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                          M.alloc (|
                            M.never_to_any (|
                              M.read (|
                                M.return_ (|
                                  Value.StructTuple
                                    "core::result::Result::Err"
                                    [
                                      Value.StructTuple
                                        "revm_interpreter::interpreter::analysis::EofValidationError::CodeSectionNotAccessed"
                                        []
                                    ]
                                |)
                              |)
                            |)
                          |)));
                      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 Function_validate_eof_codes :
      M.IsFunction "revm_interpreter::interpreter::analysis::validate_eof_codes" validate_eof_codes.
    
    (*
    Enum EofError
    {
      const_params := [];
      ty_params := [];
      variants :=
        [
          {
            name := "Decode";
            item := StructTuple [ Ty.path "revm_primitives::bytecode::eof::EofDecodeError" ];
            discriminant := None;
          };
          {
            name := "Validation";
            item :=
              StructTuple [ Ty.path "revm_interpreter::interpreter::analysis::EofValidationError" ];
            discriminant := None;
          }
        ];
    }
    *)
    
    Module Impl_core_fmt_Debug_for_revm_interpreter_interpreter_analysis_EofError.
      Definition Self : Ty.t := Ty.path "revm_interpreter::interpreter::analysis::EofError".
      
      (* Debug *)
      Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; f ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let f := M.alloc (| f |) in
            M.read (|
              M.match_operator (|
                self,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "revm_interpreter::interpreter::analysis::EofError::Decode",
                          0
                        |) in
                      let __self_0 := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::fmt::Formatter",
                            "debug_tuple_field1_finish",
                            []
                          |),
                          [ M.read (| f |); M.read (| Value.String "Decode" |); __self_0 ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "revm_interpreter::interpreter::analysis::EofError::Validation",
                          0
                        |) in
                      let __self_0 := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::fmt::Formatter",
                            "debug_tuple_field1_finish",
                            []
                          |),
                          [ M.read (| f |); M.read (| Value.String "Validation" |); __self_0 ]
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::fmt::Debug"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
    End Impl_core_fmt_Debug_for_revm_interpreter_interpreter_analysis_EofError.
    
    Module Impl_core_hash_Hash_for_revm_interpreter_interpreter_analysis_EofError.
      Definition Self : Ty.t := Ty.path "revm_interpreter::interpreter::analysis::EofError".
      
      (* Hash *)
      Definition hash (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __H ], [ self; state ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let state := M.alloc (| state |) in
            M.read (|
              let~ __self_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "revm_interpreter::interpreter::analysis::EofError" ]
                    |),
                    [ M.read (| self |) ]
                  |)
                |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::hash::Hash",
                      Ty.path "isize",
                      [],
                      "hash",
                      [ __H ]
                    |),
                    [ __self_discr; M.read (| state |) ]
                  |)
                |) in
              M.match_operator (|
                self,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "revm_interpreter::interpreter::analysis::EofError::Decode",
                          0
                        |) in
                      let __self_0 := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::hash::Hash",
                            Ty.path "revm_primitives::bytecode::eof::EofDecodeError",
                            [],
                            "hash",
                            [ __H ]
                          |),
                          [ M.read (| __self_0 |); M.read (| state |) ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "revm_interpreter::interpreter::analysis::EofError::Validation",
                          0
                        |) in
                      let __self_0 := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::hash::Hash",
                            Ty.path "revm_interpreter::interpreter::analysis::EofValidationError",
                            [],
                            "hash",
                            [ __H ]
                          |),
                          [ M.read (| __self_0 |); M.read (| state |) ]
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::hash::Hash"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("hash", InstanceField.Method hash) ].
    End Impl_core_hash_Hash_for_revm_interpreter_interpreter_analysis_EofError.
    
    Module Impl_core_marker_StructuralPartialEq_for_revm_interpreter_interpreter_analysis_EofError.
      Definition Self : Ty.t := Ty.path "revm_interpreter::interpreter::analysis::EofError".
      
      Axiom Implements :
        M.IsTraitInstance
          "core::marker::StructuralPartialEq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_marker_StructuralPartialEq_for_revm_interpreter_interpreter_analysis_EofError.
    
    Module Impl_core_cmp_PartialEq_for_revm_interpreter_interpreter_analysis_EofError.
      Definition Self : Ty.t := Ty.path "revm_interpreter::interpreter::analysis::EofError".
      
      (* PartialEq *)
      Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.read (|
              let~ __self_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "revm_interpreter::interpreter::analysis::EofError" ]
                    |),
                    [ M.read (| self |) ]
                  |)
                |) in
              let~ __arg1_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "revm_interpreter::interpreter::analysis::EofError" ]
                    |),
                    [ M.read (| other |) ]
                  |)
                |) in
              M.alloc (|
                LogicalOp.and (|
                  BinOp.eq (| M.read (| __self_discr |), M.read (| __arg1_discr |) |),
                  ltac:(M.monadic
                    (M.read (|
                      M.match_operator (|
                        M.alloc (| Value.Tuple [ M.read (| self |); M.read (| other |) ] |),
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                              let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                              let γ0_0 := M.read (| γ0_0 |) in
                              let γ2_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ0_0,
                                  "revm_interpreter::interpreter::analysis::EofError::Decode",
                                  0
                                |) in
                              let __self_0 := M.alloc (| γ2_0 |) in
                              let γ0_1 := M.read (| γ0_1 |) in
                              let γ2_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ0_1,
                                  "revm_interpreter::interpreter::analysis::EofError::Decode",
                                  0
                                |) in
                              let __arg1_0 := M.alloc (| γ2_0 |) in
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialEq",
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "revm_primitives::bytecode::eof::EofDecodeError" ],
                                    [
                                      Ty.apply
                                        (Ty.path "&")
                                        []
                                        [ Ty.path "revm_primitives::bytecode::eof::EofDecodeError" ]
                                    ],
                                    "eq",
                                    []
                                  |),
                                  [ __self_0; __arg1_0 ]
                                |)
                              |)));
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                              let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                              let γ0_0 := M.read (| γ0_0 |) in
                              let γ2_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ0_0,
                                  "revm_interpreter::interpreter::analysis::EofError::Validation",
                                  0
                                |) in
                              let __self_0 := M.alloc (| γ2_0 |) in
                              let γ0_1 := M.read (| γ0_1 |) in
                              let γ2_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ0_1,
                                  "revm_interpreter::interpreter::analysis::EofError::Validation",
                                  0
                                |) in
                              let __arg1_0 := M.alloc (| γ2_0 |) in
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialEq",
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [
                                        Ty.path
                                          "revm_interpreter::interpreter::analysis::EofValidationError"
                                      ],
                                    [
                                      Ty.apply
                                        (Ty.path "&")
                                        []
                                        [
                                          Ty.path
                                            "revm_interpreter::interpreter::analysis::EofValidationError"
                                        ]
                                    ],
                                    "eq",
                                    []
                                  |),
                                  [ __self_0; __arg1_0 ]
                                |)
                              |)));
                          fun γ =>
                            ltac:(M.monadic
                              (M.alloc (|
                                M.never_to_any (|
                                  M.call_closure (|
                                    M.get_function (| "core::intrinsics::unreachable", [] |),
                                    []
                                  |)
                                |)
                              |)))
                        ]
                      |)
                    |)))
                |)
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::PartialEq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("eq", InstanceField.Method eq) ].
    End Impl_core_cmp_PartialEq_for_revm_interpreter_interpreter_analysis_EofError.
    
    Module Impl_core_cmp_Eq_for_revm_interpreter_interpreter_analysis_EofError.
      Definition Self : Ty.t := Ty.path "revm_interpreter::interpreter::analysis::EofError".
      
      (* Eq *)
      Definition assert_receiver_is_total_eq
          (ε : list Value.t)
          (τ : list Ty.t)
          (α : list Value.t)
          : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.read (|
              M.match_operator (|
                Value.DeclaredButUndefined,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (M.match_operator (|
                        Value.DeclaredButUndefined,
                        [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ]
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::Eq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ].
    End Impl_core_cmp_Eq_for_revm_interpreter_interpreter_analysis_EofError.
    
    Module Impl_core_cmp_PartialOrd_for_revm_interpreter_interpreter_analysis_EofError.
      Definition Self : Ty.t := Ty.path "revm_interpreter::interpreter::analysis::EofError".
      
      (* PartialOrd *)
      Definition partial_cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.read (|
              let~ __self_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "revm_interpreter::interpreter::analysis::EofError" ]
                    |),
                    [ M.read (| self |) ]
                  |)
                |) in
              let~ __arg1_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "revm_interpreter::interpreter::analysis::EofError" ]
                    |),
                    [ M.read (| other |) ]
                  |)
                |) in
              M.match_operator (|
                M.alloc (| Value.Tuple [ M.read (| self |); M.read (| other |) ] |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                      let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                      let γ0_0 := M.read (| γ0_0 |) in
                      let γ2_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ0_0,
                          "revm_interpreter::interpreter::analysis::EofError::Decode",
                          0
                        |) in
                      let __self_0 := M.alloc (| γ2_0 |) in
                      let γ0_1 := M.read (| γ0_1 |) in
                      let γ2_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ0_1,
                          "revm_interpreter::interpreter::analysis::EofError::Decode",
                          0
                        |) in
                      let __arg1_0 := M.alloc (| γ2_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            Ty.path "revm_primitives::bytecode::eof::EofDecodeError",
                            [ Ty.path "revm_primitives::bytecode::eof::EofDecodeError" ],
                            "partial_cmp",
                            []
                          |),
                          [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                      let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                      let γ0_0 := M.read (| γ0_0 |) in
                      let γ2_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ0_0,
                          "revm_interpreter::interpreter::analysis::EofError::Validation",
                          0
                        |) in
                      let __self_0 := M.alloc (| γ2_0 |) in
                      let γ0_1 := M.read (| γ0_1 |) in
                      let γ2_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ0_1,
                          "revm_interpreter::interpreter::analysis::EofError::Validation",
                          0
                        |) in
                      let __arg1_0 := M.alloc (| γ2_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            Ty.path "revm_interpreter::interpreter::analysis::EofValidationError",
                            [ Ty.path "revm_interpreter::interpreter::analysis::EofValidationError"
                            ],
                            "partial_cmp",
                            []
                          |),
                          [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            Ty.path "isize",
                            [ Ty.path "isize" ],
                            "partial_cmp",
                            []
                          |),
                          [ __self_discr; __arg1_discr ]
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::PartialOrd"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("partial_cmp", InstanceField.Method partial_cmp) ].
    End Impl_core_cmp_PartialOrd_for_revm_interpreter_interpreter_analysis_EofError.
    
    Module Impl_core_cmp_Ord_for_revm_interpreter_interpreter_analysis_EofError.
      Definition Self : Ty.t := Ty.path "revm_interpreter::interpreter::analysis::EofError".
      
      (* Ord *)
      Definition cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.read (|
              let~ __self_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "revm_interpreter::interpreter::analysis::EofError" ]
                    |),
                    [ M.read (| self |) ]
                  |)
                |) in
              let~ __arg1_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "revm_interpreter::interpreter::analysis::EofError" ]
                    |),
                    [ M.read (| other |) ]
                  |)
                |) in
              M.match_operator (|
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (| "core::cmp::Ord", Ty.path "isize", [], "cmp", [] |),
                    [ __self_discr; __arg1_discr ]
                  |)
                |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                      M.match_operator (|
                        M.alloc (| Value.Tuple [ M.read (| self |); M.read (| other |) ] |),
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                              let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                              let γ0_0 := M.read (| γ0_0 |) in
                              let γ2_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ0_0,
                                  "revm_interpreter::interpreter::analysis::EofError::Decode",
                                  0
                                |) in
                              let __self_0 := M.alloc (| γ2_0 |) in
                              let γ0_1 := M.read (| γ0_1 |) in
                              let γ2_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ0_1,
                                  "revm_interpreter::interpreter::analysis::EofError::Decode",
                                  0
                                |) in
                              let __arg1_0 := M.alloc (| γ2_0 |) in
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::Ord",
                                    Ty.path "revm_primitives::bytecode::eof::EofDecodeError",
                                    [],
                                    "cmp",
                                    []
                                  |),
                                  [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                                |)
                              |)));
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                              let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                              let γ0_0 := M.read (| γ0_0 |) in
                              let γ2_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ0_0,
                                  "revm_interpreter::interpreter::analysis::EofError::Validation",
                                  0
                                |) in
                              let __self_0 := M.alloc (| γ2_0 |) in
                              let γ0_1 := M.read (| γ0_1 |) in
                              let γ2_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ0_1,
                                  "revm_interpreter::interpreter::analysis::EofError::Validation",
                                  0
                                |) in
                              let __arg1_0 := M.alloc (| γ2_0 |) in
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::Ord",
                                    Ty.path
                                      "revm_interpreter::interpreter::analysis::EofValidationError",
                                    [],
                                    "cmp",
                                    []
                                  |),
                                  [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                                |)
                              |)));
                          fun γ =>
                            ltac:(M.monadic
                              (M.alloc (|
                                M.never_to_any (|
                                  M.call_closure (|
                                    M.get_function (| "core::intrinsics::unreachable", [] |),
                                    []
                                  |)
                                |)
                              |)))
                        ]
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let cmp := M.copy (| γ |) in
                      cmp))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::Ord"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("cmp", InstanceField.Method cmp) ].
    End Impl_core_cmp_Ord_for_revm_interpreter_interpreter_analysis_EofError.
    
    Module Impl_core_clone_Clone_for_revm_interpreter_interpreter_analysis_EofError.
      Definition Self : Ty.t := Ty.path "revm_interpreter::interpreter::analysis::EofError".
      
      (* Clone *)
      Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.read (|
              M.match_operator (|
                Value.DeclaredButUndefined,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (M.match_operator (|
                        Value.DeclaredButUndefined,
                        [ fun γ => ltac:(M.monadic (M.read (| self |))) ]
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::clone::Clone"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("clone", InstanceField.Method clone) ].
    End Impl_core_clone_Clone_for_revm_interpreter_interpreter_analysis_EofError.
    
    Module Impl_core_marker_Copy_for_revm_interpreter_interpreter_analysis_EofError.
      Definition Self : Ty.t := Ty.path "revm_interpreter::interpreter::analysis::EofError".
      
      Axiom Implements :
        M.IsTraitInstance
          "core::marker::Copy"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_marker_Copy_for_revm_interpreter_interpreter_analysis_EofError.
    
    Module Impl_core_convert_From_revm_primitives_bytecode_eof_EofDecodeError_for_revm_interpreter_interpreter_analysis_EofError.
      Definition Self : Ty.t := Ty.path "revm_interpreter::interpreter::analysis::EofError".
      
      (*
          fn from(err: EofDecodeError) -> Self {
              EofError::Decode(err)
          }
      *)
      Definition from (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ err ] =>
          ltac:(M.monadic
            (let err := M.alloc (| err |) in
            Value.StructTuple
              "revm_interpreter::interpreter::analysis::EofError::Decode"
              [ M.read (| err |) ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::convert::From"
          Self
          (* Trait polymorphic types *)
          [ (* T *) Ty.path "revm_primitives::bytecode::eof::EofDecodeError" ]
          (* Instance *) [ ("from", InstanceField.Method from) ].
    End Impl_core_convert_From_revm_primitives_bytecode_eof_EofDecodeError_for_revm_interpreter_interpreter_analysis_EofError.
    
    Module Impl_core_convert_From_revm_interpreter_interpreter_analysis_EofValidationError_for_revm_interpreter_interpreter_analysis_EofError.
      Definition Self : Ty.t := Ty.path "revm_interpreter::interpreter::analysis::EofError".
      
      (*
          fn from(err: EofValidationError) -> Self {
              EofError::Validation(err)
          }
      *)
      Definition from (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ err ] =>
          ltac:(M.monadic
            (let err := M.alloc (| err |) in
            Value.StructTuple
              "revm_interpreter::interpreter::analysis::EofError::Validation"
              [ M.read (| err |) ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::convert::From"
          Self
          (* Trait polymorphic types *)
          [ (* T *) Ty.path "revm_interpreter::interpreter::analysis::EofValidationError" ]
          (* Instance *) [ ("from", InstanceField.Method from) ].
    End Impl_core_convert_From_revm_interpreter_interpreter_analysis_EofValidationError_for_revm_interpreter_interpreter_analysis_EofError.
    
    (*
    Enum EofValidationError
    {
      const_params := [];
      ty_params := [];
      variants :=
        [
          {
            name := "FalsePossitive";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "UnknownOpcode";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "OpcodeDisabled";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "InstructionNotForwardAccessed";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "MissingImmediateBytes";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "MissingRJUMPVImmediateBytes";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "JumpToImmediateBytes";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "BackwardJumpToImmediateBytes";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "RJUMPVZeroMaxIndex";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "JumpZeroOffset";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "EOFCREATEInvalidIndex";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "CodeSectionOutOfBounds";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "CALLFNonReturningFunction";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "StackOverflow";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "JUMPFEnoughOutputs";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "JUMPFStackHigherThanOutputs";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "DataLoadOutOfBounds";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "RETFBiggestStackNumMoreThenOutputs";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "StackUnderflow";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "TypesStackUnderflow";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "JumpUnderflow";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "JumpOverflow";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "BackwardJumpBiggestNumMismatch";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "BackwardJumpSmallestNumMismatch";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "LastInstructionNotTerminating";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "CodeSectionNotAccessed";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "InvalidTypesSection";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "InvalidFirstTypesSection";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "MaxStackMismatch";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "NoCodeSections";
            item := StructTuple [];
            discriminant := None;
          }
        ];
    }
    *)
    
    Module Impl_core_fmt_Debug_for_revm_interpreter_interpreter_analysis_EofValidationError.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter::analysis::EofValidationError".
      
      (* Debug *)
      Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; f ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let f := M.alloc (| f |) in
            M.call_closure (|
              M.get_associated_function (| Ty.path "core::fmt::Formatter", "write_str", [] |),
              [
                M.read (| f |);
                M.read (|
                  M.match_operator (|
                    self,
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::FalsePossitive"
                            |) in
                          M.alloc (| M.read (| Value.String "FalsePossitive" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::UnknownOpcode"
                            |) in
                          M.alloc (| M.read (| Value.String "UnknownOpcode" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::OpcodeDisabled"
                            |) in
                          M.alloc (| M.read (| Value.String "OpcodeDisabled" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::InstructionNotForwardAccessed"
                            |) in
                          M.alloc (| M.read (| Value.String "InstructionNotForwardAccessed" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::MissingImmediateBytes"
                            |) in
                          M.alloc (| M.read (| Value.String "MissingImmediateBytes" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::MissingRJUMPVImmediateBytes"
                            |) in
                          M.alloc (| M.read (| Value.String "MissingRJUMPVImmediateBytes" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::JumpToImmediateBytes"
                            |) in
                          M.alloc (| M.read (| Value.String "JumpToImmediateBytes" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::BackwardJumpToImmediateBytes"
                            |) in
                          M.alloc (| M.read (| Value.String "BackwardJumpToImmediateBytes" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::RJUMPVZeroMaxIndex"
                            |) in
                          M.alloc (| M.read (| Value.String "RJUMPVZeroMaxIndex" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::JumpZeroOffset"
                            |) in
                          M.alloc (| M.read (| Value.String "JumpZeroOffset" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::EOFCREATEInvalidIndex"
                            |) in
                          M.alloc (| M.read (| Value.String "EOFCREATEInvalidIndex" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::CodeSectionOutOfBounds"
                            |) in
                          M.alloc (| M.read (| Value.String "CodeSectionOutOfBounds" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::CALLFNonReturningFunction"
                            |) in
                          M.alloc (| M.read (| Value.String "CALLFNonReturningFunction" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::StackOverflow"
                            |) in
                          M.alloc (| M.read (| Value.String "StackOverflow" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::JUMPFEnoughOutputs"
                            |) in
                          M.alloc (| M.read (| Value.String "JUMPFEnoughOutputs" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::JUMPFStackHigherThanOutputs"
                            |) in
                          M.alloc (| M.read (| Value.String "JUMPFStackHigherThanOutputs" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::DataLoadOutOfBounds"
                            |) in
                          M.alloc (| M.read (| Value.String "DataLoadOutOfBounds" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::RETFBiggestStackNumMoreThenOutputs"
                            |) in
                          M.alloc (|
                            M.read (| Value.String "RETFBiggestStackNumMoreThenOutputs" |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::StackUnderflow"
                            |) in
                          M.alloc (| M.read (| Value.String "StackUnderflow" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::TypesStackUnderflow"
                            |) in
                          M.alloc (| M.read (| Value.String "TypesStackUnderflow" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::JumpUnderflow"
                            |) in
                          M.alloc (| M.read (| Value.String "JumpUnderflow" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::JumpOverflow"
                            |) in
                          M.alloc (| M.read (| Value.String "JumpOverflow" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::BackwardJumpBiggestNumMismatch"
                            |) in
                          M.alloc (|
                            M.read (| Value.String "BackwardJumpBiggestNumMismatch" |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::BackwardJumpSmallestNumMismatch"
                            |) in
                          M.alloc (|
                            M.read (| Value.String "BackwardJumpSmallestNumMismatch" |)
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::LastInstructionNotTerminating"
                            |) in
                          M.alloc (| M.read (| Value.String "LastInstructionNotTerminating" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::CodeSectionNotAccessed"
                            |) in
                          M.alloc (| M.read (| Value.String "CodeSectionNotAccessed" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::InvalidTypesSection"
                            |) in
                          M.alloc (| M.read (| Value.String "InvalidTypesSection" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::InvalidFirstTypesSection"
                            |) in
                          M.alloc (| M.read (| Value.String "InvalidFirstTypesSection" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::MaxStackMismatch"
                            |) in
                          M.alloc (| M.read (| Value.String "MaxStackMismatch" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter::analysis::EofValidationError::NoCodeSections"
                            |) in
                          M.alloc (| M.read (| Value.String "NoCodeSections" |) |)))
                    ]
                  |)
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::fmt::Debug"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
    End Impl_core_fmt_Debug_for_revm_interpreter_interpreter_analysis_EofValidationError.
    
    Module Impl_core_hash_Hash_for_revm_interpreter_interpreter_analysis_EofValidationError.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter::analysis::EofValidationError".
      
      (* Hash *)
      Definition hash (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __H ], [ self; state ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let state := M.alloc (| state |) in
            M.read (|
              let~ __self_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "revm_interpreter::interpreter::analysis::EofValidationError" ]
                    |),
                    [ M.read (| self |) ]
                  |)
                |) in
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::hash::Hash", Ty.path "isize", [], "hash", [ __H ] |),
                  [ __self_discr; M.read (| state |) ]
                |)
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::hash::Hash"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("hash", InstanceField.Method hash) ].
    End Impl_core_hash_Hash_for_revm_interpreter_interpreter_analysis_EofValidationError.
    
    Module Impl_core_marker_StructuralPartialEq_for_revm_interpreter_interpreter_analysis_EofValidationError.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter::analysis::EofValidationError".
      
      Axiom Implements :
        M.IsTraitInstance
          "core::marker::StructuralPartialEq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_marker_StructuralPartialEq_for_revm_interpreter_interpreter_analysis_EofValidationError.
    
    Module Impl_core_cmp_PartialEq_for_revm_interpreter_interpreter_analysis_EofValidationError.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter::analysis::EofValidationError".
      
      (* PartialEq *)
      Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.read (|
              let~ __self_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "revm_interpreter::interpreter::analysis::EofValidationError" ]
                    |),
                    [ M.read (| self |) ]
                  |)
                |) in
              let~ __arg1_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "revm_interpreter::interpreter::analysis::EofValidationError" ]
                    |),
                    [ M.read (| other |) ]
                  |)
                |) in
              M.alloc (| BinOp.eq (| M.read (| __self_discr |), M.read (| __arg1_discr |) |) |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::PartialEq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("eq", InstanceField.Method eq) ].
    End Impl_core_cmp_PartialEq_for_revm_interpreter_interpreter_analysis_EofValidationError.
    
    Module Impl_core_cmp_Eq_for_revm_interpreter_interpreter_analysis_EofValidationError.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter::analysis::EofValidationError".
      
      (* Eq *)
      Definition assert_receiver_is_total_eq
          (ε : list Value.t)
          (τ : list Ty.t)
          (α : list Value.t)
          : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            Value.Tuple []))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::Eq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ].
    End Impl_core_cmp_Eq_for_revm_interpreter_interpreter_analysis_EofValidationError.
    
    Module Impl_core_cmp_PartialOrd_for_revm_interpreter_interpreter_analysis_EofValidationError.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter::analysis::EofValidationError".
      
      (* PartialOrd *)
      Definition partial_cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.read (|
              let~ __self_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "revm_interpreter::interpreter::analysis::EofValidationError" ]
                    |),
                    [ M.read (| self |) ]
                  |)
                |) in
              let~ __arg1_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "revm_interpreter::interpreter::analysis::EofValidationError" ]
                    |),
                    [ M.read (| other |) ]
                  |)
                |) in
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (|
                    "core::cmp::PartialOrd",
                    Ty.path "isize",
                    [ Ty.path "isize" ],
                    "partial_cmp",
                    []
                  |),
                  [ __self_discr; __arg1_discr ]
                |)
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::PartialOrd"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("partial_cmp", InstanceField.Method partial_cmp) ].
    End Impl_core_cmp_PartialOrd_for_revm_interpreter_interpreter_analysis_EofValidationError.
    
    Module Impl_core_cmp_Ord_for_revm_interpreter_interpreter_analysis_EofValidationError.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter::analysis::EofValidationError".
      
      (* Ord *)
      Definition cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.read (|
              let~ __self_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "revm_interpreter::interpreter::analysis::EofValidationError" ]
                    |),
                    [ M.read (| self |) ]
                  |)
                |) in
              let~ __arg1_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "revm_interpreter::interpreter::analysis::EofValidationError" ]
                    |),
                    [ M.read (| other |) ]
                  |)
                |) in
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::Ord", Ty.path "isize", [], "cmp", [] |),
                  [ __self_discr; __arg1_discr ]
                |)
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::Ord"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("cmp", InstanceField.Method cmp) ].
    End Impl_core_cmp_Ord_for_revm_interpreter_interpreter_analysis_EofValidationError.
    
    Module Impl_core_clone_Clone_for_revm_interpreter_interpreter_analysis_EofValidationError.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter::analysis::EofValidationError".
      
      (* Clone *)
      Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.read (| M.read (| self |) |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::clone::Clone"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("clone", InstanceField.Method clone) ].
    End Impl_core_clone_Clone_for_revm_interpreter_interpreter_analysis_EofValidationError.
    
    Module Impl_core_marker_Copy_for_revm_interpreter_interpreter_analysis_EofValidationError.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter::analysis::EofValidationError".
      
      Axiom Implements :
        M.IsTraitInstance
          "core::marker::Copy"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_marker_Copy_for_revm_interpreter_interpreter_analysis_EofValidationError.
    
    (*
    pub fn validate_eof_code(
        code: &[u8],
        data_size: usize,
        this_types_index: usize,
        num_of_containers: usize,
        types: &[TypesSection],
    ) -> Result<HashSet<usize>, EofValidationError> {
        let mut accessed_codes = HashSet::<usize>::new();
        let this_types = &types[this_types_index];
    
        #[derive(Debug, Copy, Clone)]
        struct InstructionInfo {
            /// Is immediate byte, jumps can't happen on this part of code.
            is_immediate: bool,
            /// Have forward jump to this opcode. Used to check if opcode
            /// after termination is accessed.
            is_jumpdest: bool,
            /// Smallest number of stack items accessed by jumps or sequential opcodes.
            smallest: i32,
            /// Biggest number of stack items accessed by jumps or sequential opcodes.
            biggest: i32,
        }
    
        impl InstructionInfo {
            #[inline]
            fn mark_as_immediate(&mut self) -> Result<(), EofValidationError> {
                if self.is_jumpdest {
                    // Jump to immediate bytes.
                    return Err(EofValidationError::JumpToImmediateBytes);
                }
                self.is_immediate = true;
                Ok(())
            }
        }
    
        impl Default for InstructionInfo {
            fn default() -> Self {
                Self {
                    is_immediate: false,
                    is_jumpdest: false,
                    smallest: i32::MAX,
                    biggest: i32::MIN,
                }
            }
        }
    
        // all bytes that are intermediate.
        let mut jumps = vec![InstructionInfo::default(); code.len()];
        let mut is_after_termination = false;
    
        let mut next_smallest = this_types.inputs as i32;
        let mut next_biggest = this_types.inputs as i32;
    
        let mut i = 0;
        // We can check validity and jump destinations in one pass.
        while i < code.len() {
            let op = code[i];
            let opcode = &OPCODE_INFO_JUMPTABLE[op as usize];
    
            let Some(opcode) = opcode else {
                // err unknown opcode.
                return Err(EofValidationError::UnknownOpcode);
            };
    
            if opcode.is_disabled_in_eof() {
                // Opcode is disabled in EOF
                return Err(EofValidationError::OpcodeDisabled);
            }
    
            let this_instruction = &mut jumps[i];
    
            // update biggest/smallest values for next instruction only if it is not after termination.
            if !is_after_termination {
                this_instruction.smallest = core::cmp::min(this_instruction.smallest, next_smallest);
                this_instruction.biggest = core::cmp::max(this_instruction.biggest, next_biggest);
            }
    
            let this_instruction = *this_instruction;
    
            // Opcodes after termination should be accessed by forward jumps.
            if is_after_termination && !this_instruction.is_jumpdest {
                // opcode after termination was not accessed.
                return Err(EofValidationError::InstructionNotForwardAccessed);
            }
            is_after_termination = opcode.is_terminating();
    
            // mark immediate as non-jumpable. RJUMPV is special case covered later.
            if opcode.immediate_size() != 0 {
                // check if the opcode immediate are within the bounds of the code
                if i + opcode.immediate_size() as usize >= code.len() {
                    // Malfunctional code
                    return Err(EofValidationError::MissingImmediateBytes);
                }
    
                // mark immediate bytes as non-jumpable.
                for imm in 1..opcode.immediate_size() as usize + 1 {
                    // SAFETY: immediate size is checked above.
                    jumps[i + imm].mark_as_immediate()?;
                }
            }
            // IO diff used to generate next instruction smallest/biggest value.
            let mut stack_io_diff = opcode.io_diff() as i32;
            // how many stack items are required for this opcode.
            let mut stack_requirement = opcode.inputs() as i32;
            // additional immediate bytes for RJUMPV, it has dynamic vtable.
            let mut rjumpv_additional_immediates = 0;
            // If opcodes is RJUMP, RJUMPI or RJUMPV then this will have absolute jumpdest.
            let mut absolute_jumpdest = vec![];
            match op {
                opcode::RJUMP | opcode::RJUMPI => {
                    let offset = unsafe { read_i16(code.as_ptr().add(i + 1)) } as isize;
                    absolute_jumpdest = vec![offset + 3 + i as isize];
                    // RJUMP is considered a terminating opcode.
                }
                opcode::RJUMPV => {
                    // code length for RJUMPV is checked with immediate size.
                    let max_index = code[i + 1] as usize;
                    let len = max_index + 1;
                    // and max_index+1 is to get size of vtable as index starts from 0.
                    rjumpv_additional_immediates = len * 2;
    
                    // +1 is for max_index byte
                    if i + 1 + rjumpv_additional_immediates >= code.len() {
                        // Malfunctional code RJUMPV vtable is not complete
                        return Err(EofValidationError::MissingRJUMPVImmediateBytes);
                    }
    
                    // Mark vtable as immediate, max_index was already marked.
                    for imm in 0..rjumpv_additional_immediates {
                        // SAFETY: immediate size is checked above.
                        jumps[i + 2 + imm].mark_as_immediate()?;
                    }
    
                    let mut jumps = Vec::with_capacity(len);
                    for vtablei in 0..len {
                        let offset =
                            unsafe { read_i16(code.as_ptr().add(i + 2 + 2 * vtablei)) } as isize;
                        jumps.push(offset + i as isize + 2 + rjumpv_additional_immediates as isize);
                    }
                    absolute_jumpdest = jumps
                }
                opcode::CALLF => {
                    let section_i = unsafe { read_u16(code.as_ptr().add(i + 1)) } as usize;
                    let Some(target_types) = types.get(section_i) else {
                        // code section out of bounds.
                        return Err(EofValidationError::CodeSectionOutOfBounds);
                    };
    
                    if target_types.outputs == EOF_NON_RETURNING_FUNCTION {
                        // callf to non returning function is not allowed
                        return Err(EofValidationError::CALLFNonReturningFunction);
                    }
                    // stack input for this opcode is the input of the called code.
                    stack_requirement = target_types.inputs as i32;
                    // stack diff depends on input/output of the called code.
                    stack_io_diff = target_types.io_diff();
                    // mark called code as accessed.
                    accessed_codes.insert(section_i);
    
                    // we decrement by `types.inputs` as they are considered as send
                    // to the called code and included in types.max_stack_size.
                    if this_instruction.biggest - stack_requirement + target_types.max_stack_size as i32
                        > STACK_LIMIT as i32
                    {
                        // if stack max items + called code max stack size
                        return Err(EofValidationError::StackOverflow);
                    }
                }
                opcode::JUMPF => {
                    let target_index = unsafe { read_u16(code.as_ptr().add(i + 1)) } as usize;
                    // targeted code needs to have zero outputs (be non returning).
                    let Some(target_types) = types.get(target_index) else {
                        // code section out of bounds.
                        return Err(EofValidationError::CodeSectionOutOfBounds);
                    };
    
                    // we decrement types.inputs as they are considered send to the called code.
                    // and included in types.max_stack_size.
                    if this_instruction.biggest - target_types.inputs as i32
                        + target_types.max_stack_size as i32
                        > STACK_LIMIT as i32
                    {
                        // stack overflow
                        return Err(EofValidationError::StackOverflow);
                    }
                    accessed_codes.insert(target_index);
    
                    if target_types.outputs == EOF_NON_RETURNING_FUNCTION {
                        // if it is not returning
                        stack_requirement = target_types.inputs as i32;
                    } else {
                        // check if target code produces enough outputs.
                        if this_types.outputs < target_types.outputs {
                            return Err(EofValidationError::JUMPFEnoughOutputs);
                        }
    
                        stack_requirement = this_types.outputs as i32 + target_types.inputs as i32
                            - target_types.outputs as i32;
    
                        // Stack requirement needs to more than this instruction biggest stack number.
                        if this_instruction.biggest > stack_requirement {
                            return Err(EofValidationError::JUMPFStackHigherThanOutputs);
                        }
    
                        // if this instruction max + target_types max is more then stack limit.
                        if this_instruction.biggest + stack_requirement > STACK_LIMIT as i32 {
                            return Err(EofValidationError::StackOverflow);
                        }
                    }
                }
                opcode::EOFCREATE => {
                    let index = code[i + 1] as usize;
                    if index >= num_of_containers {
                        // code section out of bounds.
                        return Err(EofValidationError::EOFCREATEInvalidIndex);
                    }
                }
                opcode::DATALOADN => {
                    let index = unsafe { read_u16(code.as_ptr().add(i + 1)) } as isize;
                    if data_size < 32 || index > data_size as isize - 32 {
                        // data load out of bounds.
                        return Err(EofValidationError::DataLoadOutOfBounds);
                    }
                }
                opcode::RETF => {
                    stack_requirement = this_types.outputs as i32;
                    if this_instruction.biggest > stack_requirement {
                        return Err(EofValidationError::RETFBiggestStackNumMoreThenOutputs);
                    }
                }
                opcode::DUPN => {
                    stack_requirement = code[i + 1] as i32 + 1;
                }
                opcode::SWAPN => {
                    stack_requirement = code[i + 1] as i32 + 2;
                }
                opcode::EXCHANGE => {
                    let imm = code[i + 1];
                    let n = (imm >> 4) + 1;
                    let m = (imm & 0x0F) + 1;
                    stack_requirement = n as i32 + m as i32 + 1;
                }
                _ => {}
            }
            // check if stack requirement is more than smallest stack items.
            if stack_requirement > this_instruction.smallest {
                // opcode requirement is more than smallest stack items.
                return Err(EofValidationError::StackUnderflow);
            }
    
            next_smallest = this_instruction.smallest + stack_io_diff;
            next_biggest = this_instruction.biggest + stack_io_diff;
    
            // check if jumpdest are correct and mark forward jumps.
            for absolute_jump in absolute_jumpdest {
                if absolute_jump < 0 {
                    // jump out of bounds.
                    return Err(EofValidationError::JumpUnderflow);
                }
                if absolute_jump >= code.len() as isize {
                    // jump to out of bounds
                    return Err(EofValidationError::JumpOverflow);
                }
                // fine to cast as bounds are checked.
                let absolute_jump = absolute_jump as usize;
    
                let target_jump = &mut jumps[absolute_jump];
                if target_jump.is_immediate {
                    // Jump target is immediate byte.
                    return Err(EofValidationError::BackwardJumpToImmediateBytes);
                }
    
                // needed to mark forward jumps. It does not do anything for backward jumps.
                target_jump.is_jumpdest = true;
    
                if absolute_jump <= i {
                    // backward jumps should have same smallest and biggest stack items.
                    if target_jump.biggest != next_biggest {
                        // wrong jumpdest.
                        return Err(EofValidationError::BackwardJumpBiggestNumMismatch);
                    }
                    if target_jump.smallest != next_smallest {
                        // wrong jumpdest.
                        return Err(EofValidationError::BackwardJumpSmallestNumMismatch);
                    }
                } else {
                    // forward jumps can make min even smallest size
                    // while biggest num is needed to check stack overflow
                    target_jump.smallest = core::cmp::min(target_jump.smallest, next_smallest);
                    target_jump.biggest = core::cmp::max(target_jump.biggest, next_biggest);
                }
            }
    
            // additional immediate are from RJUMPV vtable.
            i += 1 + opcode.immediate_size() as usize + rjumpv_additional_immediates;
        }
    
        // last opcode should be terminating
        if !is_after_termination {
            // wrong termination.
            return Err(EofValidationError::LastInstructionNotTerminating);
        }
        // TODO integrate max so we dont need to iterate again
        let mut max_stack_requirement = 0;
        for opcode in jumps {
            max_stack_requirement = core::cmp::max(opcode.biggest, max_stack_requirement);
        }
    
        if max_stack_requirement != types[this_types_index].max_stack_size as i32 {
            // stack overflow
            return Err(EofValidationError::MaxStackMismatch);
        }
    
        Ok(accessed_codes)
    }
    *)
    Definition validate_eof_code (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ code; data_size; this_types_index; num_of_containers; types ] =>
        ltac:(M.monadic
          (let code := M.alloc (| code |) in
          let data_size := M.alloc (| data_size |) in
          let this_types_index := M.alloc (| this_types_index |) in
          let num_of_containers := M.alloc (| num_of_containers |) in
          let types := M.alloc (| types |) in
          M.catch_return (|
            ltac:(M.monadic
              (M.read (|
                let~ accessed_codes :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_associated_function (|
                        Ty.apply
                          (Ty.path "std::collections::hash::set::HashSet")
                          []
                          [ Ty.path "usize"; Ty.path "std::hash::random::RandomState" ],
                        "new",
                        []
                      |),
                      []
                    |)
                  |) in
                let~ this_types :=
                  M.alloc (|
                    M.SubPointer.get_array_field (| M.read (| types |), this_types_index |)
                  |) in
                let~ jumps :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_function (|
                        "alloc::vec::from_elem",
                        [
                          Ty.path
                            "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo"
                        ]
                      |),
                      [
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::default::Default",
                            Ty.path
                              "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                            [],
                            "default",
                            []
                          |),
                          []
                        |);
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.apply (Ty.path "slice") [] [ Ty.path "u8" ],
                            "len",
                            []
                          |),
                          [ M.read (| code |) ]
                        |)
                      ]
                    |)
                  |) in
                let~ is_after_termination := M.alloc (| Value.Bool false |) in
                let~ next_smallest :=
                  M.alloc (|
                    M.rust_cast
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| this_types |),
                          "revm_primitives::bytecode::eof::types_section::TypesSection",
                          "inputs"
                        |)
                      |))
                  |) in
                let~ next_biggest :=
                  M.alloc (|
                    M.rust_cast
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| this_types |),
                          "revm_primitives::bytecode::eof::types_section::TypesSection",
                          "inputs"
                        |)
                      |))
                  |) in
                let~ i := M.alloc (| Value.Integer IntegerKind.Usize 0 |) in
                let~ _ :=
                  M.loop (|
                    ltac:(M.monadic
                      (M.match_operator (|
                        M.alloc (| Value.Tuple [] |),
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let γ :=
                                M.use
                                  (M.alloc (|
                                    BinOp.lt (|
                                      M.read (| i |),
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.apply (Ty.path "slice") [] [ Ty.path "u8" ],
                                          "len",
                                          []
                                        |),
                                        [ M.read (| code |) ]
                                      |)
                                    |)
                                  |)) in
                              let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ |),
                                  Value.Bool true
                                |) in
                              let~ op :=
                                M.copy (|
                                  M.SubPointer.get_array_field (| M.read (| code |), i |)
                                |) in
                              let~ opcode :=
                                M.alloc (|
                                  M.SubPointer.get_array_field (|
                                    M.get_constant (|
                                      "revm_interpreter::opcode::OPCODE_INFO_JUMPTABLE"
                                    |),
                                    M.alloc (| M.rust_cast (M.read (| op |)) |)
                                  |)
                                |) in
                              M.match_operator (|
                                opcode,
                                [
                                  fun γ =>
                                    ltac:(M.monadic
                                      (let γ := M.read (| γ |) in
                                      let γ1_0 :=
                                        M.SubPointer.get_struct_tuple_field (|
                                          γ,
                                          "core::option::Option::Some",
                                          0
                                        |) in
                                      let opcode := M.alloc (| γ1_0 |) in
                                      let~ _ :=
                                        M.match_operator (|
                                          M.alloc (| Value.Tuple [] |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ :=
                                                  M.use
                                                    (M.alloc (|
                                                      M.call_closure (|
                                                        M.get_associated_function (|
                                                          Ty.path
                                                            "revm_interpreter::opcode::OpCodeInfo",
                                                          "is_disabled_in_eof",
                                                          []
                                                        |),
                                                        [ M.read (| opcode |) ]
                                                      |)
                                                    |)) in
                                                let _ :=
                                                  M.is_constant_or_break_match (|
                                                    M.read (| γ |),
                                                    Value.Bool true
                                                  |) in
                                                M.alloc (|
                                                  M.never_to_any (|
                                                    M.read (|
                                                      M.return_ (|
                                                        Value.StructTuple
                                                          "core::result::Result::Err"
                                                          [
                                                            Value.StructTuple
                                                              "revm_interpreter::interpreter::analysis::EofValidationError::OpcodeDisabled"
                                                              []
                                                          ]
                                                      |)
                                                    |)
                                                  |)
                                                |)));
                                            fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                          ]
                                        |) in
                                      let~ this_instruction :=
                                        M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::ops::index::IndexMut",
                                              Ty.apply
                                                (Ty.path "alloc::vec::Vec")
                                                []
                                                [
                                                  Ty.path
                                                    "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo";
                                                  Ty.path "alloc::alloc::Global"
                                                ],
                                              [ Ty.path "usize" ],
                                              "index_mut",
                                              []
                                            |),
                                            [ jumps; M.read (| i |) ]
                                          |)
                                        |) in
                                      let~ _ :=
                                        M.match_operator (|
                                          M.alloc (| Value.Tuple [] |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ :=
                                                  M.use
                                                    (M.alloc (|
                                                      UnOp.not (|
                                                        M.read (| is_after_termination |)
                                                      |)
                                                    |)) in
                                                let _ :=
                                                  M.is_constant_or_break_match (|
                                                    M.read (| γ |),
                                                    Value.Bool true
                                                  |) in
                                                let~ _ :=
                                                  M.write (|
                                                    M.SubPointer.get_struct_record_field (|
                                                      M.read (| this_instruction |),
                                                      "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                      "smallest"
                                                    |),
                                                    M.call_closure (|
                                                      M.get_function (|
                                                        "core::cmp::min",
                                                        [ Ty.path "i32" ]
                                                      |),
                                                      [
                                                        M.read (|
                                                          M.SubPointer.get_struct_record_field (|
                                                            M.read (| this_instruction |),
                                                            "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                            "smallest"
                                                          |)
                                                        |);
                                                        M.read (| next_smallest |)
                                                      ]
                                                    |)
                                                  |) in
                                                let~ _ :=
                                                  M.write (|
                                                    M.SubPointer.get_struct_record_field (|
                                                      M.read (| this_instruction |),
                                                      "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                      "biggest"
                                                    |),
                                                    M.call_closure (|
                                                      M.get_function (|
                                                        "core::cmp::max",
                                                        [ Ty.path "i32" ]
                                                      |),
                                                      [
                                                        M.read (|
                                                          M.SubPointer.get_struct_record_field (|
                                                            M.read (| this_instruction |),
                                                            "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                            "biggest"
                                                          |)
                                                        |);
                                                        M.read (| next_biggest |)
                                                      ]
                                                    |)
                                                  |) in
                                                M.alloc (| Value.Tuple [] |)));
                                            fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                          ]
                                        |) in
                                      let~ this_instruction :=
                                        M.copy (| M.read (| this_instruction |) |) in
                                      let~ _ :=
                                        M.match_operator (|
                                          M.alloc (| Value.Tuple [] |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ :=
                                                  M.use
                                                    (M.alloc (|
                                                      LogicalOp.and (|
                                                        M.read (| is_after_termination |),
                                                        ltac:(M.monadic
                                                          (UnOp.not (|
                                                            M.read (|
                                                              M.SubPointer.get_struct_record_field (|
                                                                this_instruction,
                                                                "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                                "is_jumpdest"
                                                              |)
                                                            |)
                                                          |)))
                                                      |)
                                                    |)) in
                                                let _ :=
                                                  M.is_constant_or_break_match (|
                                                    M.read (| γ |),
                                                    Value.Bool true
                                                  |) in
                                                M.alloc (|
                                                  M.never_to_any (|
                                                    M.read (|
                                                      M.return_ (|
                                                        Value.StructTuple
                                                          "core::result::Result::Err"
                                                          [
                                                            Value.StructTuple
                                                              "revm_interpreter::interpreter::analysis::EofValidationError::InstructionNotForwardAccessed"
                                                              []
                                                          ]
                                                      |)
                                                    |)
                                                  |)
                                                |)));
                                            fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                          ]
                                        |) in
                                      let~ _ :=
                                        M.write (|
                                          is_after_termination,
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "revm_interpreter::opcode::OpCodeInfo",
                                              "is_terminating",
                                              []
                                            |),
                                            [ M.read (| opcode |) ]
                                          |)
                                        |) in
                                      let~ _ :=
                                        M.match_operator (|
                                          M.alloc (| Value.Tuple [] |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ :=
                                                  M.use
                                                    (M.alloc (|
                                                      BinOp.ne (|
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path
                                                              "revm_interpreter::opcode::OpCodeInfo",
                                                            "immediate_size",
                                                            []
                                                          |),
                                                          [ M.read (| opcode |) ]
                                                        |),
                                                        Value.Integer IntegerKind.U8 0
                                                      |)
                                                    |)) 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 (|
                                                                BinOp.ge (|
                                                                  BinOp.Wrap.add (|
                                                                    M.read (| i |),
                                                                    M.rust_cast
                                                                      (M.call_closure (|
                                                                        M.get_associated_function (|
                                                                          Ty.path
                                                                            "revm_interpreter::opcode::OpCodeInfo",
                                                                          "immediate_size",
                                                                          []
                                                                        |),
                                                                        [ M.read (| opcode |) ]
                                                                      |))
                                                                  |),
                                                                  M.call_closure (|
                                                                    M.get_associated_function (|
                                                                      Ty.apply
                                                                        (Ty.path "slice")
                                                                        []
                                                                        [ Ty.path "u8" ],
                                                                      "len",
                                                                      []
                                                                    |),
                                                                    [ M.read (| code |) ]
                                                                  |)
                                                                |)
                                                              |)) in
                                                          let _ :=
                                                            M.is_constant_or_break_match (|
                                                              M.read (| γ |),
                                                              Value.Bool true
                                                            |) in
                                                          M.alloc (|
                                                            M.never_to_any (|
                                                              M.read (|
                                                                M.return_ (|
                                                                  Value.StructTuple
                                                                    "core::result::Result::Err"
                                                                    [
                                                                      Value.StructTuple
                                                                        "revm_interpreter::interpreter::analysis::EofValidationError::MissingImmediateBytes"
                                                                        []
                                                                    ]
                                                                |)
                                                              |)
                                                            |)
                                                          |)));
                                                      fun γ =>
                                                        ltac:(M.monadic
                                                          (M.alloc (| Value.Tuple [] |)))
                                                    ]
                                                  |) in
                                                M.use
                                                  (M.match_operator (|
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::iter::traits::collect::IntoIterator",
                                                          Ty.apply
                                                            (Ty.path "core::ops::range::Range")
                                                            []
                                                            [ Ty.path "usize" ],
                                                          [],
                                                          "into_iter",
                                                          []
                                                        |),
                                                        [
                                                          Value.StructRecord
                                                            "core::ops::range::Range"
                                                            [
                                                              ("start",
                                                                Value.Integer IntegerKind.Usize 1);
                                                              ("end_",
                                                                BinOp.Wrap.add (|
                                                                  M.rust_cast
                                                                    (M.call_closure (|
                                                                      M.get_associated_function (|
                                                                        Ty.path
                                                                          "revm_interpreter::opcode::OpCodeInfo",
                                                                        "immediate_size",
                                                                        []
                                                                      |),
                                                                      [ M.read (| opcode |) ]
                                                                    |)),
                                                                  Value.Integer IntegerKind.Usize 1
                                                                |))
                                                            ]
                                                        ]
                                                      |)
                                                    |),
                                                    [
                                                      fun γ =>
                                                        ltac:(M.monadic
                                                          (let iter := M.copy (| γ |) in
                                                          M.loop (|
                                                            ltac:(M.monadic
                                                              (let~ _ :=
                                                                M.match_operator (|
                                                                  M.alloc (|
                                                                    M.call_closure (|
                                                                      M.get_trait_method (|
                                                                        "core::iter::traits::iterator::Iterator",
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::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 imm :=
                                                                          M.copy (| γ0_0 |) in
                                                                        let~ _ :=
                                                                          M.match_operator (|
                                                                            M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::ops::try_trait::Try",
                                                                                  Ty.apply
                                                                                    (Ty.path
                                                                                      "core::result::Result")
                                                                                    []
                                                                                    [
                                                                                      Ty.tuple [];
                                                                                      Ty.path
                                                                                        "revm_interpreter::interpreter::analysis::EofValidationError"
                                                                                    ],
                                                                                  [],
                                                                                  "branch",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  M.call_closure (|
                                                                                    M.get_associated_function (|
                                                                                      Ty.path
                                                                                        "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                                                      "mark_as_immediate",
                                                                                      []
                                                                                    |),
                                                                                    [
                                                                                      M.call_closure (|
                                                                                        M.get_trait_method (|
                                                                                          "core::ops::index::IndexMut",
                                                                                          Ty.apply
                                                                                            (Ty.path
                                                                                              "alloc::vec::Vec")
                                                                                            []
                                                                                            [
                                                                                              Ty.path
                                                                                                "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo";
                                                                                              Ty.path
                                                                                                "alloc::alloc::Global"
                                                                                            ],
                                                                                          [
                                                                                            Ty.path
                                                                                              "usize"
                                                                                          ],
                                                                                          "index_mut",
                                                                                          []
                                                                                        |),
                                                                                        [
                                                                                          jumps;
                                                                                          BinOp.Wrap.add (|
                                                                                            M.read (|
                                                                                              i
                                                                                            |),
                                                                                            M.read (|
                                                                                              imm
                                                                                            |)
                                                                                          |)
                                                                                        ]
                                                                                      |)
                                                                                    ]
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |),
                                                                            [
                                                                              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.apply
                                                                                                    (Ty.path
                                                                                                      "std::collections::hash::set::HashSet")
                                                                                                    []
                                                                                                    [
                                                                                                      Ty.path
                                                                                                        "usize";
                                                                                                      Ty.path
                                                                                                        "std::hash::random::RandomState"
                                                                                                    ];
                                                                                                  Ty.path
                                                                                                    "revm_interpreter::interpreter::analysis::EofValidationError"
                                                                                                ],
                                                                                              [
                                                                                                Ty.apply
                                                                                                  (Ty.path
                                                                                                    "core::result::Result")
                                                                                                  []
                                                                                                  [
                                                                                                    Ty.path
                                                                                                      "core::convert::Infallible";
                                                                                                    Ty.path
                                                                                                      "revm_interpreter::interpreter::analysis::EofValidationError"
                                                                                                  ]
                                                                                              ],
                                                                                              "from_residual",
                                                                                              []
                                                                                            |),
                                                                                            [
                                                                                              M.read (|
                                                                                                residual
                                                                                              |)
                                                                                            ]
                                                                                          |)
                                                                                        |)
                                                                                      |)
                                                                                    |)
                                                                                  |)));
                                                                              fun γ =>
                                                                                ltac:(M.monadic
                                                                                  (let γ0_0 :=
                                                                                    M.SubPointer.get_struct_tuple_field (|
                                                                                      γ,
                                                                                      "core::ops::control_flow::ControlFlow::Continue",
                                                                                      0
                                                                                    |) in
                                                                                  let val :=
                                                                                    M.copy (|
                                                                                      γ0_0
                                                                                    |) in
                                                                                  val))
                                                                            ]
                                                                          |) in
                                                                        M.alloc (|
                                                                          Value.Tuple []
                                                                        |)))
                                                                  ]
                                                                |) in
                                                              M.alloc (| Value.Tuple [] |)))
                                                          |)))
                                                    ]
                                                  |))));
                                            fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                          ]
                                        |) in
                                      let~ stack_io_diff :=
                                        M.alloc (|
                                          M.rust_cast
                                            (M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path "revm_interpreter::opcode::OpCodeInfo",
                                                "io_diff",
                                                []
                                              |),
                                              [ M.read (| opcode |) ]
                                            |))
                                        |) in
                                      let~ stack_requirement :=
                                        M.alloc (|
                                          M.rust_cast
                                            (M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path "revm_interpreter::opcode::OpCodeInfo",
                                                "inputs",
                                                []
                                              |),
                                              [ M.read (| opcode |) ]
                                            |))
                                        |) in
                                      let~ rjumpv_additional_immediates :=
                                        M.alloc (| Value.Integer IntegerKind.Usize 0 |) in
                                      let~ absolute_jumpdest :=
                                        M.alloc (|
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.apply
                                                (Ty.path "alloc::vec::Vec")
                                                []
                                                [ Ty.path "isize"; Ty.path "alloc::alloc::Global" ],
                                              "new",
                                              []
                                            |),
                                            []
                                          |)
                                        |) in
                                      let~ _ :=
                                        M.match_operator (|
                                          op,
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (M.find_or_pattern (|
                                                  γ,
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let _ :=
                                                          M.is_constant_or_break_match (|
                                                            M.read (| γ |),
                                                            Value.Integer IntegerKind.U8 224
                                                          |) in
                                                        Value.Tuple []));
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let _ :=
                                                          M.is_constant_or_break_match (|
                                                            M.read (| γ |),
                                                            Value.Integer IntegerKind.U8 225
                                                          |) in
                                                        Value.Tuple []))
                                                  ],
                                                  M.closure
                                                    (fun γ =>
                                                      ltac:(M.monadic
                                                        match γ with
                                                        | [] =>
                                                          ltac:(M.monadic
                                                            (let~ offset :=
                                                              M.alloc (|
                                                                M.rust_cast
                                                                  (M.call_closure (|
                                                                    M.get_function (|
                                                                      "revm_interpreter::instructions::utility::read_i16",
                                                                      []
                                                                    |),
                                                                    [
                                                                      M.call_closure (|
                                                                        M.get_associated_function (|
                                                                          Ty.apply
                                                                            (Ty.path "*const")
                                                                            []
                                                                            [ Ty.path "u8" ],
                                                                          "add",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.call_closure (|
                                                                            M.get_associated_function (|
                                                                              Ty.apply
                                                                                (Ty.path "slice")
                                                                                []
                                                                                [ Ty.path "u8" ],
                                                                              "as_ptr",
                                                                              []
                                                                            |),
                                                                            [ M.read (| code |) ]
                                                                          |);
                                                                          BinOp.Wrap.add (|
                                                                            M.read (| i |),
                                                                            Value.Integer
                                                                              IntegerKind.Usize
                                                                              1
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    ]
                                                                  |))
                                                              |) in
                                                            let~ _ :=
                                                              M.write (|
                                                                absolute_jumpdest,
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.apply
                                                                      (Ty.path "slice")
                                                                      []
                                                                      [ Ty.path "isize" ],
                                                                    "into_vec",
                                                                    [ Ty.path "alloc::alloc::Global"
                                                                    ]
                                                                  |),
                                                                  [
                                                                    M.read (|
                                                                      M.call_closure (|
                                                                        M.get_associated_function (|
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "alloc::boxed::Box")
                                                                            []
                                                                            [
                                                                              Ty.apply
                                                                                (Ty.path "array")
                                                                                [
                                                                                  Value.Integer
                                                                                    IntegerKind.Usize
                                                                                    1
                                                                                ]
                                                                                [ Ty.path "isize" ];
                                                                              Ty.path
                                                                                "alloc::alloc::Global"
                                                                            ],
                                                                          "new",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.alloc (|
                                                                            Value.Array
                                                                              [
                                                                                BinOp.Wrap.add (|
                                                                                  BinOp.Wrap.add (|
                                                                                    M.read (|
                                                                                      offset
                                                                                    |),
                                                                                    Value.Integer
                                                                                      IntegerKind.Isize
                                                                                      3
                                                                                  |),
                                                                                  M.rust_cast
                                                                                    (M.read (| i |))
                                                                                |)
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.alloc (| Value.Tuple [] |)))
                                                        | _ =>
                                                          M.impossible "wrong number of arguments"
                                                        end))
                                                |)));
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let _ :=
                                                  M.is_constant_or_break_match (|
                                                    M.read (| γ |),
                                                    Value.Integer IntegerKind.U8 226
                                                  |) in
                                                let~ max_index :=
                                                  M.alloc (|
                                                    M.rust_cast
                                                      (M.read (|
                                                        M.SubPointer.get_array_field (|
                                                          M.read (| code |),
                                                          M.alloc (|
                                                            BinOp.Wrap.add (|
                                                              M.read (| i |),
                                                              Value.Integer IntegerKind.Usize 1
                                                            |)
                                                          |)
                                                        |)
                                                      |))
                                                  |) in
                                                let~ len :=
                                                  M.alloc (|
                                                    BinOp.Wrap.add (|
                                                      M.read (| max_index |),
                                                      Value.Integer IntegerKind.Usize 1
                                                    |)
                                                  |) in
                                                let~ _ :=
                                                  M.write (|
                                                    rjumpv_additional_immediates,
                                                    BinOp.Wrap.mul (|
                                                      M.read (| len |),
                                                      Value.Integer IntegerKind.Usize 2
                                                    |)
                                                  |) in
                                                let~ _ :=
                                                  M.match_operator (|
                                                    M.alloc (| Value.Tuple [] |),
                                                    [
                                                      fun γ =>
                                                        ltac:(M.monadic
                                                          (let γ :=
                                                            M.use
                                                              (M.alloc (|
                                                                BinOp.ge (|
                                                                  BinOp.Wrap.add (|
                                                                    BinOp.Wrap.add (|
                                                                      M.read (| i |),
                                                                      Value.Integer
                                                                        IntegerKind.Usize
                                                                        1
                                                                    |),
                                                                    M.read (|
                                                                      rjumpv_additional_immediates
                                                                    |)
                                                                  |),
                                                                  M.call_closure (|
                                                                    M.get_associated_function (|
                                                                      Ty.apply
                                                                        (Ty.path "slice")
                                                                        []
                                                                        [ Ty.path "u8" ],
                                                                      "len",
                                                                      []
                                                                    |),
                                                                    [ M.read (| code |) ]
                                                                  |)
                                                                |)
                                                              |)) in
                                                          let _ :=
                                                            M.is_constant_or_break_match (|
                                                              M.read (| γ |),
                                                              Value.Bool true
                                                            |) in
                                                          M.alloc (|
                                                            M.never_to_any (|
                                                              M.read (|
                                                                M.return_ (|
                                                                  Value.StructTuple
                                                                    "core::result::Result::Err"
                                                                    [
                                                                      Value.StructTuple
                                                                        "revm_interpreter::interpreter::analysis::EofValidationError::MissingRJUMPVImmediateBytes"
                                                                        []
                                                                    ]
                                                                |)
                                                              |)
                                                            |)
                                                          |)));
                                                      fun γ =>
                                                        ltac:(M.monadic
                                                          (M.alloc (| Value.Tuple [] |)))
                                                    ]
                                                  |) in
                                                let~ _ :=
                                                  M.use
                                                    (M.match_operator (|
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::iter::traits::collect::IntoIterator",
                                                            Ty.apply
                                                              (Ty.path "core::ops::range::Range")
                                                              []
                                                              [ Ty.path "usize" ],
                                                            [],
                                                            "into_iter",
                                                            []
                                                          |),
                                                          [
                                                            Value.StructRecord
                                                              "core::ops::range::Range"
                                                              [
                                                                ("start",
                                                                  Value.Integer
                                                                    IntegerKind.Usize
                                                                    0);
                                                                ("end_",
                                                                  M.read (|
                                                                    rjumpv_additional_immediates
                                                                  |))
                                                              ]
                                                          ]
                                                        |)
                                                      |),
                                                      [
                                                        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 imm :=
                                                                            M.copy (| γ0_0 |) in
                                                                          let~ _ :=
                                                                            M.match_operator (|
                                                                              M.alloc (|
                                                                                M.call_closure (|
                                                                                  M.get_trait_method (|
                                                                                    "core::ops::try_trait::Try",
                                                                                    Ty.apply
                                                                                      (Ty.path
                                                                                        "core::result::Result")
                                                                                      []
                                                                                      [
                                                                                        Ty.tuple [];
                                                                                        Ty.path
                                                                                          "revm_interpreter::interpreter::analysis::EofValidationError"
                                                                                      ],
                                                                                    [],
                                                                                    "branch",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    M.call_closure (|
                                                                                      M.get_associated_function (|
                                                                                        Ty.path
                                                                                          "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                                                        "mark_as_immediate",
                                                                                        []
                                                                                      |),
                                                                                      [
                                                                                        M.call_closure (|
                                                                                          M.get_trait_method (|
                                                                                            "core::ops::index::IndexMut",
                                                                                            Ty.apply
                                                                                              (Ty.path
                                                                                                "alloc::vec::Vec")
                                                                                              []
                                                                                              [
                                                                                                Ty.path
                                                                                                  "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo";
                                                                                                Ty.path
                                                                                                  "alloc::alloc::Global"
                                                                                              ],
                                                                                            [
                                                                                              Ty.path
                                                                                                "usize"
                                                                                            ],
                                                                                            "index_mut",
                                                                                            []
                                                                                          |),
                                                                                          [
                                                                                            jumps;
                                                                                            BinOp.Wrap.add (|
                                                                                              BinOp.Wrap.add (|
                                                                                                M.read (|
                                                                                                  i
                                                                                                |),
                                                                                                Value.Integer
                                                                                                  IntegerKind.Usize
                                                                                                  2
                                                                                              |),
                                                                                              M.read (|
                                                                                                imm
                                                                                              |)
                                                                                            |)
                                                                                          ]
                                                                                        |)
                                                                                      ]
                                                                                    |)
                                                                                  ]
                                                                                |)
                                                                              |),
                                                                              [
                                                                                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.apply
                                                                                                      (Ty.path
                                                                                                        "std::collections::hash::set::HashSet")
                                                                                                      []
                                                                                                      [
                                                                                                        Ty.path
                                                                                                          "usize";
                                                                                                        Ty.path
                                                                                                          "std::hash::random::RandomState"
                                                                                                      ];
                                                                                                    Ty.path
                                                                                                      "revm_interpreter::interpreter::analysis::EofValidationError"
                                                                                                  ],
                                                                                                [
                                                                                                  Ty.apply
                                                                                                    (Ty.path
                                                                                                      "core::result::Result")
                                                                                                    []
                                                                                                    [
                                                                                                      Ty.path
                                                                                                        "core::convert::Infallible";
                                                                                                      Ty.path
                                                                                                        "revm_interpreter::interpreter::analysis::EofValidationError"
                                                                                                    ]
                                                                                                ],
                                                                                                "from_residual",
                                                                                                []
                                                                                              |),
                                                                                              [
                                                                                                M.read (|
                                                                                                  residual
                                                                                                |)
                                                                                              ]
                                                                                            |)
                                                                                          |)
                                                                                        |)
                                                                                      |)
                                                                                    |)));
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let γ0_0 :=
                                                                                      M.SubPointer.get_struct_tuple_field (|
                                                                                        γ,
                                                                                        "core::ops::control_flow::ControlFlow::Continue",
                                                                                        0
                                                                                      |) in
                                                                                    let val :=
                                                                                      M.copy (|
                                                                                        γ0_0
                                                                                      |) in
                                                                                    val))
                                                                              ]
                                                                            |) in
                                                                          M.alloc (|
                                                                            Value.Tuple []
                                                                          |)))
                                                                    ]
                                                                  |) in
                                                                M.alloc (| Value.Tuple [] |)))
                                                            |)))
                                                      ]
                                                    |)) in
                                                let~ jumps :=
                                                  M.alloc (|
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.apply
                                                          (Ty.path "alloc::vec::Vec")
                                                          []
                                                          [
                                                            Ty.path "isize";
                                                            Ty.path "alloc::alloc::Global"
                                                          ],
                                                        "with_capacity",
                                                        []
                                                      |),
                                                      [ M.read (| len |) ]
                                                    |)
                                                  |) 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.read (| len |))
                                                              ]
                                                          ]
                                                        |)
                                                      |),
                                                      [
                                                        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 vtablei :=
                                                                            M.copy (| γ0_0 |) in
                                                                          let~ offset :=
                                                                            M.alloc (|
                                                                              M.rust_cast
                                                                                (M.call_closure (|
                                                                                  M.get_function (|
                                                                                    "revm_interpreter::instructions::utility::read_i16",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    M.call_closure (|
                                                                                      M.get_associated_function (|
                                                                                        Ty.apply
                                                                                          (Ty.path
                                                                                            "*const")
                                                                                          []
                                                                                          [
                                                                                            Ty.path
                                                                                              "u8"
                                                                                          ],
                                                                                        "add",
                                                                                        []
                                                                                      |),
                                                                                      [
                                                                                        M.call_closure (|
                                                                                          M.get_associated_function (|
                                                                                            Ty.apply
                                                                                              (Ty.path
                                                                                                "slice")
                                                                                              []
                                                                                              [
                                                                                                Ty.path
                                                                                                  "u8"
                                                                                              ],
                                                                                            "as_ptr",
                                                                                            []
                                                                                          |),
                                                                                          [
                                                                                            M.read (|
                                                                                              code
                                                                                            |)
                                                                                          ]
                                                                                        |);
                                                                                        BinOp.Wrap.add (|
                                                                                          BinOp.Wrap.add (|
                                                                                            M.read (|
                                                                                              i
                                                                                            |),
                                                                                            Value.Integer
                                                                                              IntegerKind.Usize
                                                                                              2
                                                                                          |),
                                                                                          BinOp.Wrap.mul (|
                                                                                            Value.Integer
                                                                                              IntegerKind.Usize
                                                                                              2,
                                                                                            M.read (|
                                                                                              vtablei
                                                                                            |)
                                                                                          |)
                                                                                        |)
                                                                                      ]
                                                                                    |)
                                                                                  ]
                                                                                |))
                                                                            |) in
                                                                          let~ _ :=
                                                                            M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_associated_function (|
                                                                                  Ty.apply
                                                                                    (Ty.path
                                                                                      "alloc::vec::Vec")
                                                                                    []
                                                                                    [
                                                                                      Ty.path
                                                                                        "isize";
                                                                                      Ty.path
                                                                                        "alloc::alloc::Global"
                                                                                    ],
                                                                                  "push",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  jumps;
                                                                                  BinOp.Wrap.add (|
                                                                                    BinOp.Wrap.add (|
                                                                                      BinOp.Wrap.add (|
                                                                                        M.read (|
                                                                                          offset
                                                                                        |),
                                                                                        M.rust_cast
                                                                                          (M.read (|
                                                                                            i
                                                                                          |))
                                                                                      |),
                                                                                      Value.Integer
                                                                                        IntegerKind.Isize
                                                                                        2
                                                                                    |),
                                                                                    M.rust_cast
                                                                                      (M.read (|
                                                                                        rjumpv_additional_immediates
                                                                                      |))
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |) in
                                                                          M.alloc (|
                                                                            Value.Tuple []
                                                                          |)))
                                                                    ]
                                                                  |) in
                                                                M.alloc (| Value.Tuple [] |)))
                                                            |)))
                                                      ]
                                                    |)) in
                                                M.write (|
                                                  absolute_jumpdest,
                                                  M.read (| jumps |)
                                                |)));
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let _ :=
                                                  M.is_constant_or_break_match (|
                                                    M.read (| γ |),
                                                    Value.Integer IntegerKind.U8 227
                                                  |) in
                                                let~ section_i :=
                                                  M.alloc (|
                                                    M.rust_cast
                                                      (M.call_closure (|
                                                        M.get_function (|
                                                          "revm_interpreter::instructions::utility::read_u16",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.apply
                                                                (Ty.path "*const")
                                                                []
                                                                [ Ty.path "u8" ],
                                                              "add",
                                                              []
                                                            |),
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.apply
                                                                    (Ty.path "slice")
                                                                    []
                                                                    [ Ty.path "u8" ],
                                                                  "as_ptr",
                                                                  []
                                                                |),
                                                                [ M.read (| code |) ]
                                                              |);
                                                              BinOp.Wrap.add (|
                                                                M.read (| i |),
                                                                Value.Integer IntegerKind.Usize 1
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |))
                                                  |) in
                                                M.match_operator (|
                                                  M.alloc (|
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.apply
                                                          (Ty.path "slice")
                                                          []
                                                          [
                                                            Ty.path
                                                              "revm_primitives::bytecode::eof::types_section::TypesSection"
                                                          ],
                                                        "get",
                                                        [ Ty.path "usize" ]
                                                      |),
                                                      [ M.read (| types |); M.read (| section_i |) ]
                                                    |)
                                                  |),
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let γ0_0 :=
                                                          M.SubPointer.get_struct_tuple_field (|
                                                            γ,
                                                            "core::option::Option::Some",
                                                            0
                                                          |) in
                                                        let target_types := M.copy (| γ0_0 |) in
                                                        let~ _ :=
                                                          M.match_operator (|
                                                            M.alloc (| Value.Tuple [] |),
                                                            [
                                                              fun γ =>
                                                                ltac:(M.monadic
                                                                  (let γ :=
                                                                    M.use
                                                                      (M.alloc (|
                                                                        BinOp.eq (|
                                                                          M.read (|
                                                                            M.SubPointer.get_struct_record_field (|
                                                                              M.read (|
                                                                                target_types
                                                                              |),
                                                                              "revm_primitives::bytecode::eof::types_section::TypesSection",
                                                                              "outputs"
                                                                            |)
                                                                          |),
                                                                          M.read (|
                                                                            M.get_constant (|
                                                                              "revm_interpreter::interpreter::analysis::EOF_NON_RETURNING_FUNCTION"
                                                                            |)
                                                                          |)
                                                                        |)
                                                                      |)) in
                                                                  let _ :=
                                                                    M.is_constant_or_break_match (|
                                                                      M.read (| γ |),
                                                                      Value.Bool true
                                                                    |) in
                                                                  M.alloc (|
                                                                    M.never_to_any (|
                                                                      M.read (|
                                                                        M.return_ (|
                                                                          Value.StructTuple
                                                                            "core::result::Result::Err"
                                                                            [
                                                                              Value.StructTuple
                                                                                "revm_interpreter::interpreter::analysis::EofValidationError::CALLFNonReturningFunction"
                                                                                []
                                                                            ]
                                                                        |)
                                                                      |)
                                                                    |)
                                                                  |)));
                                                              fun γ =>
                                                                ltac:(M.monadic
                                                                  (M.alloc (| Value.Tuple [] |)))
                                                            ]
                                                          |) in
                                                        let~ _ :=
                                                          M.write (|
                                                            stack_requirement,
                                                            M.rust_cast
                                                              (M.read (|
                                                                M.SubPointer.get_struct_record_field (|
                                                                  M.read (| target_types |),
                                                                  "revm_primitives::bytecode::eof::types_section::TypesSection",
                                                                  "inputs"
                                                                |)
                                                              |))
                                                          |) in
                                                        let~ _ :=
                                                          M.write (|
                                                            stack_io_diff,
                                                            M.call_closure (|
                                                              M.get_associated_function (|
                                                                Ty.path
                                                                  "revm_primitives::bytecode::eof::types_section::TypesSection",
                                                                "io_diff",
                                                                []
                                                              |),
                                                              [ M.read (| target_types |) ]
                                                            |)
                                                          |) in
                                                        let~ _ :=
                                                          M.alloc (|
                                                            M.call_closure (|
                                                              M.get_associated_function (|
                                                                Ty.apply
                                                                  (Ty.path
                                                                    "std::collections::hash::set::HashSet")
                                                                  []
                                                                  [
                                                                    Ty.path "usize";
                                                                    Ty.path
                                                                      "std::hash::random::RandomState"
                                                                  ],
                                                                "insert",
                                                                []
                                                              |),
                                                              [
                                                                accessed_codes;
                                                                M.read (| section_i |)
                                                              ]
                                                            |)
                                                          |) in
                                                        M.match_operator (|
                                                          M.alloc (| Value.Tuple [] |),
                                                          [
                                                            fun γ =>
                                                              ltac:(M.monadic
                                                                (let γ :=
                                                                  M.use
                                                                    (M.alloc (|
                                                                      BinOp.gt (|
                                                                        BinOp.Wrap.add (|
                                                                          BinOp.Wrap.sub (|
                                                                            M.read (|
                                                                              M.SubPointer.get_struct_record_field (|
                                                                                this_instruction,
                                                                                "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                                                "biggest"
                                                                              |)
                                                                            |),
                                                                            M.read (|
                                                                              stack_requirement
                                                                            |)
                                                                          |),
                                                                          M.rust_cast
                                                                            (M.read (|
                                                                              M.SubPointer.get_struct_record_field (|
                                                                                M.read (|
                                                                                  target_types
                                                                                |),
                                                                                "revm_primitives::bytecode::eof::types_section::TypesSection",
                                                                                "max_stack_size"
                                                                              |)
                                                                            |))
                                                                        |),
                                                                        M.rust_cast
                                                                          (M.read (|
                                                                            M.get_constant (|
                                                                              "revm_interpreter::interpreter::stack::STACK_LIMIT"
                                                                            |)
                                                                          |))
                                                                      |)
                                                                    |)) in
                                                                let _ :=
                                                                  M.is_constant_or_break_match (|
                                                                    M.read (| γ |),
                                                                    Value.Bool true
                                                                  |) in
                                                                M.alloc (|
                                                                  M.never_to_any (|
                                                                    M.read (|
                                                                      M.return_ (|
                                                                        Value.StructTuple
                                                                          "core::result::Result::Err"
                                                                          [
                                                                            Value.StructTuple
                                                                              "revm_interpreter::interpreter::analysis::EofValidationError::StackOverflow"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    |)
                                                                  |)
                                                                |)));
                                                            fun γ =>
                                                              ltac:(M.monadic
                                                                (M.alloc (| Value.Tuple [] |)))
                                                          ]
                                                        |)))
                                                  ]
                                                |)));
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let _ :=
                                                  M.is_constant_or_break_match (|
                                                    M.read (| γ |),
                                                    Value.Integer IntegerKind.U8 229
                                                  |) in
                                                let~ target_index :=
                                                  M.alloc (|
                                                    M.rust_cast
                                                      (M.call_closure (|
                                                        M.get_function (|
                                                          "revm_interpreter::instructions::utility::read_u16",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.apply
                                                                (Ty.path "*const")
                                                                []
                                                                [ Ty.path "u8" ],
                                                              "add",
                                                              []
                                                            |),
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.apply
                                                                    (Ty.path "slice")
                                                                    []
                                                                    [ Ty.path "u8" ],
                                                                  "as_ptr",
                                                                  []
                                                                |),
                                                                [ M.read (| code |) ]
                                                              |);
                                                              BinOp.Wrap.add (|
                                                                M.read (| i |),
                                                                Value.Integer IntegerKind.Usize 1
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |))
                                                  |) in
                                                M.match_operator (|
                                                  M.alloc (|
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.apply
                                                          (Ty.path "slice")
                                                          []
                                                          [
                                                            Ty.path
                                                              "revm_primitives::bytecode::eof::types_section::TypesSection"
                                                          ],
                                                        "get",
                                                        [ Ty.path "usize" ]
                                                      |),
                                                      [
                                                        M.read (| types |);
                                                        M.read (| target_index |)
                                                      ]
                                                    |)
                                                  |),
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let γ0_0 :=
                                                          M.SubPointer.get_struct_tuple_field (|
                                                            γ,
                                                            "core::option::Option::Some",
                                                            0
                                                          |) in
                                                        let target_types := M.copy (| γ0_0 |) in
                                                        let~ _ :=
                                                          M.match_operator (|
                                                            M.alloc (| Value.Tuple [] |),
                                                            [
                                                              fun γ =>
                                                                ltac:(M.monadic
                                                                  (let γ :=
                                                                    M.use
                                                                      (M.alloc (|
                                                                        BinOp.gt (|
                                                                          BinOp.Wrap.add (|
                                                                            BinOp.Wrap.sub (|
                                                                              M.read (|
                                                                                M.SubPointer.get_struct_record_field (|
                                                                                  this_instruction,
                                                                                  "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                                                  "biggest"
                                                                                |)
                                                                              |),
                                                                              M.rust_cast
                                                                                (M.read (|
                                                                                  M.SubPointer.get_struct_record_field (|
                                                                                    M.read (|
                                                                                      target_types
                                                                                    |),
                                                                                    "revm_primitives::bytecode::eof::types_section::TypesSection",
                                                                                    "inputs"
                                                                                  |)
                                                                                |))
                                                                            |),
                                                                            M.rust_cast
                                                                              (M.read (|
                                                                                M.SubPointer.get_struct_record_field (|
                                                                                  M.read (|
                                                                                    target_types
                                                                                  |),
                                                                                  "revm_primitives::bytecode::eof::types_section::TypesSection",
                                                                                  "max_stack_size"
                                                                                |)
                                                                              |))
                                                                          |),
                                                                          M.rust_cast
                                                                            (M.read (|
                                                                              M.get_constant (|
                                                                                "revm_interpreter::interpreter::stack::STACK_LIMIT"
                                                                              |)
                                                                            |))
                                                                        |)
                                                                      |)) in
                                                                  let _ :=
                                                                    M.is_constant_or_break_match (|
                                                                      M.read (| γ |),
                                                                      Value.Bool true
                                                                    |) in
                                                                  M.alloc (|
                                                                    M.never_to_any (|
                                                                      M.read (|
                                                                        M.return_ (|
                                                                          Value.StructTuple
                                                                            "core::result::Result::Err"
                                                                            [
                                                                              Value.StructTuple
                                                                                "revm_interpreter::interpreter::analysis::EofValidationError::StackOverflow"
                                                                                []
                                                                            ]
                                                                        |)
                                                                      |)
                                                                    |)
                                                                  |)));
                                                              fun γ =>
                                                                ltac:(M.monadic
                                                                  (M.alloc (| Value.Tuple [] |)))
                                                            ]
                                                          |) in
                                                        let~ _ :=
                                                          M.alloc (|
                                                            M.call_closure (|
                                                              M.get_associated_function (|
                                                                Ty.apply
                                                                  (Ty.path
                                                                    "std::collections::hash::set::HashSet")
                                                                  []
                                                                  [
                                                                    Ty.path "usize";
                                                                    Ty.path
                                                                      "std::hash::random::RandomState"
                                                                  ],
                                                                "insert",
                                                                []
                                                              |),
                                                              [
                                                                accessed_codes;
                                                                M.read (| target_index |)
                                                              ]
                                                            |)
                                                          |) in
                                                        M.match_operator (|
                                                          M.alloc (| Value.Tuple [] |),
                                                          [
                                                            fun γ =>
                                                              ltac:(M.monadic
                                                                (let γ :=
                                                                  M.use
                                                                    (M.alloc (|
                                                                      BinOp.eq (|
                                                                        M.read (|
                                                                          M.SubPointer.get_struct_record_field (|
                                                                            M.read (|
                                                                              target_types
                                                                            |),
                                                                            "revm_primitives::bytecode::eof::types_section::TypesSection",
                                                                            "outputs"
                                                                          |)
                                                                        |),
                                                                        M.read (|
                                                                          M.get_constant (|
                                                                            "revm_interpreter::interpreter::analysis::EOF_NON_RETURNING_FUNCTION"
                                                                          |)
                                                                        |)
                                                                      |)
                                                                    |)) in
                                                                let _ :=
                                                                  M.is_constant_or_break_match (|
                                                                    M.read (| γ |),
                                                                    Value.Bool true
                                                                  |) in
                                                                let~ _ :=
                                                                  M.write (|
                                                                    stack_requirement,
                                                                    M.rust_cast
                                                                      (M.read (|
                                                                        M.SubPointer.get_struct_record_field (|
                                                                          M.read (| target_types |),
                                                                          "revm_primitives::bytecode::eof::types_section::TypesSection",
                                                                          "inputs"
                                                                        |)
                                                                      |))
                                                                  |) in
                                                                M.alloc (| Value.Tuple [] |)));
                                                            fun γ =>
                                                              ltac:(M.monadic
                                                                (let~ _ :=
                                                                  M.match_operator (|
                                                                    M.alloc (| Value.Tuple [] |),
                                                                    [
                                                                      fun γ =>
                                                                        ltac:(M.monadic
                                                                          (let γ :=
                                                                            M.use
                                                                              (M.alloc (|
                                                                                BinOp.lt (|
                                                                                  M.read (|
                                                                                    M.SubPointer.get_struct_record_field (|
                                                                                      M.read (|
                                                                                        this_types
                                                                                      |),
                                                                                      "revm_primitives::bytecode::eof::types_section::TypesSection",
                                                                                      "outputs"
                                                                                    |)
                                                                                  |),
                                                                                  M.read (|
                                                                                    M.SubPointer.get_struct_record_field (|
                                                                                      M.read (|
                                                                                        target_types
                                                                                      |),
                                                                                      "revm_primitives::bytecode::eof::types_section::TypesSection",
                                                                                      "outputs"
                                                                                    |)
                                                                                  |)
                                                                                |)
                                                                              |)) in
                                                                          let _ :=
                                                                            M.is_constant_or_break_match (|
                                                                              M.read (| γ |),
                                                                              Value.Bool true
                                                                            |) in
                                                                          M.alloc (|
                                                                            M.never_to_any (|
                                                                              M.read (|
                                                                                M.return_ (|
                                                                                  Value.StructTuple
                                                                                    "core::result::Result::Err"
                                                                                    [
                                                                                      Value.StructTuple
                                                                                        "revm_interpreter::interpreter::analysis::EofValidationError::JUMPFEnoughOutputs"
                                                                                        []
                                                                                    ]
                                                                                |)
                                                                              |)
                                                                            |)
                                                                          |)));
                                                                      fun γ =>
                                                                        ltac:(M.monadic
                                                                          (M.alloc (|
                                                                            Value.Tuple []
                                                                          |)))
                                                                    ]
                                                                  |) in
                                                                let~ _ :=
                                                                  M.write (|
                                                                    stack_requirement,
                                                                    BinOp.Wrap.sub (|
                                                                      BinOp.Wrap.add (|
                                                                        M.rust_cast
                                                                          (M.read (|
                                                                            M.SubPointer.get_struct_record_field (|
                                                                              M.read (|
                                                                                this_types
                                                                              |),
                                                                              "revm_primitives::bytecode::eof::types_section::TypesSection",
                                                                              "outputs"
                                                                            |)
                                                                          |)),
                                                                        M.rust_cast
                                                                          (M.read (|
                                                                            M.SubPointer.get_struct_record_field (|
                                                                              M.read (|
                                                                                target_types
                                                                              |),
                                                                              "revm_primitives::bytecode::eof::types_section::TypesSection",
                                                                              "inputs"
                                                                            |)
                                                                          |))
                                                                      |),
                                                                      M.rust_cast
                                                                        (M.read (|
                                                                          M.SubPointer.get_struct_record_field (|
                                                                            M.read (|
                                                                              target_types
                                                                            |),
                                                                            "revm_primitives::bytecode::eof::types_section::TypesSection",
                                                                            "outputs"
                                                                          |)
                                                                        |))
                                                                    |)
                                                                  |) in
                                                                let~ _ :=
                                                                  M.match_operator (|
                                                                    M.alloc (| Value.Tuple [] |),
                                                                    [
                                                                      fun γ =>
                                                                        ltac:(M.monadic
                                                                          (let γ :=
                                                                            M.use
                                                                              (M.alloc (|
                                                                                BinOp.gt (|
                                                                                  M.read (|
                                                                                    M.SubPointer.get_struct_record_field (|
                                                                                      this_instruction,
                                                                                      "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                                                      "biggest"
                                                                                    |)
                                                                                  |),
                                                                                  M.read (|
                                                                                    stack_requirement
                                                                                  |)
                                                                                |)
                                                                              |)) in
                                                                          let _ :=
                                                                            M.is_constant_or_break_match (|
                                                                              M.read (| γ |),
                                                                              Value.Bool true
                                                                            |) in
                                                                          M.alloc (|
                                                                            M.never_to_any (|
                                                                              M.read (|
                                                                                M.return_ (|
                                                                                  Value.StructTuple
                                                                                    "core::result::Result::Err"
                                                                                    [
                                                                                      Value.StructTuple
                                                                                        "revm_interpreter::interpreter::analysis::EofValidationError::JUMPFStackHigherThanOutputs"
                                                                                        []
                                                                                    ]
                                                                                |)
                                                                              |)
                                                                            |)
                                                                          |)));
                                                                      fun γ =>
                                                                        ltac:(M.monadic
                                                                          (M.alloc (|
                                                                            Value.Tuple []
                                                                          |)))
                                                                    ]
                                                                  |) in
                                                                M.match_operator (|
                                                                  M.alloc (| Value.Tuple [] |),
                                                                  [
                                                                    fun γ =>
                                                                      ltac:(M.monadic
                                                                        (let γ :=
                                                                          M.use
                                                                            (M.alloc (|
                                                                              BinOp.gt (|
                                                                                BinOp.Wrap.add (|
                                                                                  M.read (|
                                                                                    M.SubPointer.get_struct_record_field (|
                                                                                      this_instruction,
                                                                                      "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                                                      "biggest"
                                                                                    |)
                                                                                  |),
                                                                                  M.read (|
                                                                                    stack_requirement
                                                                                  |)
                                                                                |),
                                                                                M.rust_cast
                                                                                  (M.read (|
                                                                                    M.get_constant (|
                                                                                      "revm_interpreter::interpreter::stack::STACK_LIMIT"
                                                                                    |)
                                                                                  |))
                                                                              |)
                                                                            |)) in
                                                                        let _ :=
                                                                          M.is_constant_or_break_match (|
                                                                            M.read (| γ |),
                                                                            Value.Bool true
                                                                          |) in
                                                                        M.alloc (|
                                                                          M.never_to_any (|
                                                                            M.read (|
                                                                              M.return_ (|
                                                                                Value.StructTuple
                                                                                  "core::result::Result::Err"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "revm_interpreter::interpreter::analysis::EofValidationError::StackOverflow"
                                                                                      []
                                                                                  ]
                                                                              |)
                                                                            |)
                                                                          |)
                                                                        |)));
                                                                    fun γ =>
                                                                      ltac:(M.monadic
                                                                        (M.alloc (|
                                                                          Value.Tuple []
                                                                        |)))
                                                                  ]
                                                                |)))
                                                          ]
                                                        |)))
                                                  ]
                                                |)));
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let _ :=
                                                  M.is_constant_or_break_match (|
                                                    M.read (| γ |),
                                                    Value.Integer IntegerKind.U8 236
                                                  |) in
                                                let~ index :=
                                                  M.alloc (|
                                                    M.rust_cast
                                                      (M.read (|
                                                        M.SubPointer.get_array_field (|
                                                          M.read (| code |),
                                                          M.alloc (|
                                                            BinOp.Wrap.add (|
                                                              M.read (| i |),
                                                              Value.Integer IntegerKind.Usize 1
                                                            |)
                                                          |)
                                                        |)
                                                      |))
                                                  |) in
                                                M.match_operator (|
                                                  M.alloc (| Value.Tuple [] |),
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let γ :=
                                                          M.use
                                                            (M.alloc (|
                                                              BinOp.ge (|
                                                                M.read (| index |),
                                                                M.read (| num_of_containers |)
                                                              |)
                                                            |)) in
                                                        let _ :=
                                                          M.is_constant_or_break_match (|
                                                            M.read (| γ |),
                                                            Value.Bool true
                                                          |) in
                                                        M.alloc (|
                                                          M.never_to_any (|
                                                            M.read (|
                                                              M.return_ (|
                                                                Value.StructTuple
                                                                  "core::result::Result::Err"
                                                                  [
                                                                    Value.StructTuple
                                                                      "revm_interpreter::interpreter::analysis::EofValidationError::EOFCREATEInvalidIndex"
                                                                      []
                                                                  ]
                                                              |)
                                                            |)
                                                          |)
                                                        |)));
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (M.alloc (| Value.Tuple [] |)))
                                                  ]
                                                |)));
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let _ :=
                                                  M.is_constant_or_break_match (|
                                                    M.read (| γ |),
                                                    Value.Integer IntegerKind.U8 209
                                                  |) in
                                                let~ index :=
                                                  M.alloc (|
                                                    M.rust_cast
                                                      (M.call_closure (|
                                                        M.get_function (|
                                                          "revm_interpreter::instructions::utility::read_u16",
                                                          []
                                                        |),
                                                        [
                                                          M.call_closure (|
                                                            M.get_associated_function (|
                                                              Ty.apply
                                                                (Ty.path "*const")
                                                                []
                                                                [ Ty.path "u8" ],
                                                              "add",
                                                              []
                                                            |),
                                                            [
                                                              M.call_closure (|
                                                                M.get_associated_function (|
                                                                  Ty.apply
                                                                    (Ty.path "slice")
                                                                    []
                                                                    [ Ty.path "u8" ],
                                                                  "as_ptr",
                                                                  []
                                                                |),
                                                                [ M.read (| code |) ]
                                                              |);
                                                              BinOp.Wrap.add (|
                                                                M.read (| i |),
                                                                Value.Integer IntegerKind.Usize 1
                                                              |)
                                                            ]
                                                          |)
                                                        ]
                                                      |))
                                                  |) in
                                                M.match_operator (|
                                                  M.alloc (| Value.Tuple [] |),
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let γ :=
                                                          M.use
                                                            (M.alloc (|
                                                              LogicalOp.or (|
                                                                BinOp.lt (|
                                                                  M.read (| data_size |),
                                                                  Value.Integer IntegerKind.Usize 32
                                                                |),
                                                                ltac:(M.monadic
                                                                  (BinOp.gt (|
                                                                    M.read (| index |),
                                                                    BinOp.Wrap.sub (|
                                                                      M.rust_cast
                                                                        (M.read (| data_size |)),
                                                                      Value.Integer
                                                                        IntegerKind.Isize
                                                                        32
                                                                    |)
                                                                  |)))
                                                              |)
                                                            |)) in
                                                        let _ :=
                                                          M.is_constant_or_break_match (|
                                                            M.read (| γ |),
                                                            Value.Bool true
                                                          |) in
                                                        M.alloc (|
                                                          M.never_to_any (|
                                                            M.read (|
                                                              M.return_ (|
                                                                Value.StructTuple
                                                                  "core::result::Result::Err"
                                                                  [
                                                                    Value.StructTuple
                                                                      "revm_interpreter::interpreter::analysis::EofValidationError::DataLoadOutOfBounds"
                                                                      []
                                                                  ]
                                                              |)
                                                            |)
                                                          |)
                                                        |)));
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (M.alloc (| Value.Tuple [] |)))
                                                  ]
                                                |)));
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let _ :=
                                                  M.is_constant_or_break_match (|
                                                    M.read (| γ |),
                                                    Value.Integer IntegerKind.U8 228
                                                  |) in
                                                let~ _ :=
                                                  M.write (|
                                                    stack_requirement,
                                                    M.rust_cast
                                                      (M.read (|
                                                        M.SubPointer.get_struct_record_field (|
                                                          M.read (| this_types |),
                                                          "revm_primitives::bytecode::eof::types_section::TypesSection",
                                                          "outputs"
                                                        |)
                                                      |))
                                                  |) in
                                                M.match_operator (|
                                                  M.alloc (| Value.Tuple [] |),
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let γ :=
                                                          M.use
                                                            (M.alloc (|
                                                              BinOp.gt (|
                                                                M.read (|
                                                                  M.SubPointer.get_struct_record_field (|
                                                                    this_instruction,
                                                                    "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                                    "biggest"
                                                                  |)
                                                                |),
                                                                M.read (| stack_requirement |)
                                                              |)
                                                            |)) in
                                                        let _ :=
                                                          M.is_constant_or_break_match (|
                                                            M.read (| γ |),
                                                            Value.Bool true
                                                          |) in
                                                        M.alloc (|
                                                          M.never_to_any (|
                                                            M.read (|
                                                              M.return_ (|
                                                                Value.StructTuple
                                                                  "core::result::Result::Err"
                                                                  [
                                                                    Value.StructTuple
                                                                      "revm_interpreter::interpreter::analysis::EofValidationError::RETFBiggestStackNumMoreThenOutputs"
                                                                      []
                                                                  ]
                                                              |)
                                                            |)
                                                          |)
                                                        |)));
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (M.alloc (| Value.Tuple [] |)))
                                                  ]
                                                |)));
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let _ :=
                                                  M.is_constant_or_break_match (|
                                                    M.read (| γ |),
                                                    Value.Integer IntegerKind.U8 230
                                                  |) in
                                                let~ _ :=
                                                  M.write (|
                                                    stack_requirement,
                                                    BinOp.Wrap.add (|
                                                      M.rust_cast
                                                        (M.read (|
                                                          M.SubPointer.get_array_field (|
                                                            M.read (| code |),
                                                            M.alloc (|
                                                              BinOp.Wrap.add (|
                                                                M.read (| i |),
                                                                Value.Integer IntegerKind.Usize 1
                                                              |)
                                                            |)
                                                          |)
                                                        |)),
                                                      Value.Integer IntegerKind.I32 1
                                                    |)
                                                  |) in
                                                M.alloc (| Value.Tuple [] |)));
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let _ :=
                                                  M.is_constant_or_break_match (|
                                                    M.read (| γ |),
                                                    Value.Integer IntegerKind.U8 231
                                                  |) in
                                                let~ _ :=
                                                  M.write (|
                                                    stack_requirement,
                                                    BinOp.Wrap.add (|
                                                      M.rust_cast
                                                        (M.read (|
                                                          M.SubPointer.get_array_field (|
                                                            M.read (| code |),
                                                            M.alloc (|
                                                              BinOp.Wrap.add (|
                                                                M.read (| i |),
                                                                Value.Integer IntegerKind.Usize 1
                                                              |)
                                                            |)
                                                          |)
                                                        |)),
                                                      Value.Integer IntegerKind.I32 2
                                                    |)
                                                  |) in
                                                M.alloc (| Value.Tuple [] |)));
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let _ :=
                                                  M.is_constant_or_break_match (|
                                                    M.read (| γ |),
                                                    Value.Integer IntegerKind.U8 232
                                                  |) in
                                                let~ imm :=
                                                  M.copy (|
                                                    M.SubPointer.get_array_field (|
                                                      M.read (| code |),
                                                      M.alloc (|
                                                        BinOp.Wrap.add (|
                                                          M.read (| i |),
                                                          Value.Integer IntegerKind.Usize 1
                                                        |)
                                                      |)
                                                    |)
                                                  |) in
                                                let~ n :=
                                                  M.alloc (|
                                                    BinOp.Wrap.add (|
                                                      BinOp.Wrap.shr (|
                                                        M.read (| imm |),
                                                        Value.Integer IntegerKind.I32 4
                                                      |),
                                                      Value.Integer IntegerKind.U8 1
                                                    |)
                                                  |) in
                                                let~ m :=
                                                  M.alloc (|
                                                    BinOp.Wrap.add (|
                                                      BinOp.bit_and
                                                        (M.read (| imm |))
                                                        (Value.Integer IntegerKind.U8 15),
                                                      Value.Integer IntegerKind.U8 1
                                                    |)
                                                  |) in
                                                let~ _ :=
                                                  M.write (|
                                                    stack_requirement,
                                                    BinOp.Wrap.add (|
                                                      BinOp.Wrap.add (|
                                                        M.rust_cast (M.read (| n |)),
                                                        M.rust_cast (M.read (| m |))
                                                      |),
                                                      Value.Integer IntegerKind.I32 1
                                                    |)
                                                  |) in
                                                M.alloc (| Value.Tuple [] |)));
                                            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 (|
                                                      BinOp.gt (|
                                                        M.read (| stack_requirement |),
                                                        M.read (|
                                                          M.SubPointer.get_struct_record_field (|
                                                            this_instruction,
                                                            "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                            "smallest"
                                                          |)
                                                        |)
                                                      |)
                                                    |)) in
                                                let _ :=
                                                  M.is_constant_or_break_match (|
                                                    M.read (| γ |),
                                                    Value.Bool true
                                                  |) in
                                                M.alloc (|
                                                  M.never_to_any (|
                                                    M.read (|
                                                      M.return_ (|
                                                        Value.StructTuple
                                                          "core::result::Result::Err"
                                                          [
                                                            Value.StructTuple
                                                              "revm_interpreter::interpreter::analysis::EofValidationError::StackUnderflow"
                                                              []
                                                          ]
                                                      |)
                                                    |)
                                                  |)
                                                |)));
                                            fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                          ]
                                        |) in
                                      let~ _ :=
                                        M.write (|
                                          next_smallest,
                                          BinOp.Wrap.add (|
                                            M.read (|
                                              M.SubPointer.get_struct_record_field (|
                                                this_instruction,
                                                "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                "smallest"
                                              |)
                                            |),
                                            M.read (| stack_io_diff |)
                                          |)
                                        |) in
                                      let~ _ :=
                                        M.write (|
                                          next_biggest,
                                          BinOp.Wrap.add (|
                                            M.read (|
                                              M.SubPointer.get_struct_record_field (|
                                                this_instruction,
                                                "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                "biggest"
                                              |)
                                            |),
                                            M.read (| stack_io_diff |)
                                          |)
                                        |) 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 "isize";
                                                      Ty.path "alloc::alloc::Global"
                                                    ],
                                                  [],
                                                  "into_iter",
                                                  []
                                                |),
                                                [ M.read (| absolute_jumpdest |) ]
                                              |)
                                            |),
                                            [
                                              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 "isize";
                                                                    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 absolute_jump :=
                                                                  M.copy (| γ0_0 |) in
                                                                let~ _ :=
                                                                  M.match_operator (|
                                                                    M.alloc (| Value.Tuple [] |),
                                                                    [
                                                                      fun γ =>
                                                                        ltac:(M.monadic
                                                                          (let γ :=
                                                                            M.use
                                                                              (M.alloc (|
                                                                                BinOp.lt (|
                                                                                  M.read (|
                                                                                    absolute_jump
                                                                                  |),
                                                                                  Value.Integer
                                                                                    IntegerKind.Isize
                                                                                    0
                                                                                |)
                                                                              |)) in
                                                                          let _ :=
                                                                            M.is_constant_or_break_match (|
                                                                              M.read (| γ |),
                                                                              Value.Bool true
                                                                            |) in
                                                                          M.alloc (|
                                                                            M.never_to_any (|
                                                                              M.read (|
                                                                                M.return_ (|
                                                                                  Value.StructTuple
                                                                                    "core::result::Result::Err"
                                                                                    [
                                                                                      Value.StructTuple
                                                                                        "revm_interpreter::interpreter::analysis::EofValidationError::JumpUnderflow"
                                                                                        []
                                                                                    ]
                                                                                |)
                                                                              |)
                                                                            |)
                                                                          |)));
                                                                      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 (|
                                                                                BinOp.ge (|
                                                                                  M.read (|
                                                                                    absolute_jump
                                                                                  |),
                                                                                  M.rust_cast
                                                                                    (M.call_closure (|
                                                                                      M.get_associated_function (|
                                                                                        Ty.apply
                                                                                          (Ty.path
                                                                                            "slice")
                                                                                          []
                                                                                          [
                                                                                            Ty.path
                                                                                              "u8"
                                                                                          ],
                                                                                        "len",
                                                                                        []
                                                                                      |),
                                                                                      [
                                                                                        M.read (|
                                                                                          code
                                                                                        |)
                                                                                      ]
                                                                                    |))
                                                                                |)
                                                                              |)) in
                                                                          let _ :=
                                                                            M.is_constant_or_break_match (|
                                                                              M.read (| γ |),
                                                                              Value.Bool true
                                                                            |) in
                                                                          M.alloc (|
                                                                            M.never_to_any (|
                                                                              M.read (|
                                                                                M.return_ (|
                                                                                  Value.StructTuple
                                                                                    "core::result::Result::Err"
                                                                                    [
                                                                                      Value.StructTuple
                                                                                        "revm_interpreter::interpreter::analysis::EofValidationError::JumpOverflow"
                                                                                        []
                                                                                    ]
                                                                                |)
                                                                              |)
                                                                            |)
                                                                          |)));
                                                                      fun γ =>
                                                                        ltac:(M.monadic
                                                                          (M.alloc (|
                                                                            Value.Tuple []
                                                                          |)))
                                                                    ]
                                                                  |) in
                                                                let~ absolute_jump :=
                                                                  M.alloc (|
                                                                    M.rust_cast
                                                                      (M.read (| absolute_jump |))
                                                                  |) in
                                                                let~ target_jump :=
                                                                  M.alloc (|
                                                                    M.call_closure (|
                                                                      M.get_trait_method (|
                                                                        "core::ops::index::IndexMut",
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "alloc::vec::Vec")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo";
                                                                            Ty.path
                                                                              "alloc::alloc::Global"
                                                                          ],
                                                                        [ Ty.path "usize" ],
                                                                        "index_mut",
                                                                        []
                                                                      |),
                                                                      [
                                                                        jumps;
                                                                        M.read (| absolute_jump |)
                                                                      ]
                                                                    |)
                                                                  |) in
                                                                let~ _ :=
                                                                  M.match_operator (|
                                                                    M.alloc (| Value.Tuple [] |),
                                                                    [
                                                                      fun γ =>
                                                                        ltac:(M.monadic
                                                                          (let γ :=
                                                                            M.use
                                                                              (M.SubPointer.get_struct_record_field (|
                                                                                M.read (|
                                                                                  target_jump
                                                                                |),
                                                                                "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                                                "is_immediate"
                                                                              |)) in
                                                                          let _ :=
                                                                            M.is_constant_or_break_match (|
                                                                              M.read (| γ |),
                                                                              Value.Bool true
                                                                            |) in
                                                                          M.alloc (|
                                                                            M.never_to_any (|
                                                                              M.read (|
                                                                                M.return_ (|
                                                                                  Value.StructTuple
                                                                                    "core::result::Result::Err"
                                                                                    [
                                                                                      Value.StructTuple
                                                                                        "revm_interpreter::interpreter::analysis::EofValidationError::BackwardJumpToImmediateBytes"
                                                                                        []
                                                                                    ]
                                                                                |)
                                                                              |)
                                                                            |)
                                                                          |)));
                                                                      fun γ =>
                                                                        ltac:(M.monadic
                                                                          (M.alloc (|
                                                                            Value.Tuple []
                                                                          |)))
                                                                    ]
                                                                  |) in
                                                                let~ _ :=
                                                                  M.write (|
                                                                    M.SubPointer.get_struct_record_field (|
                                                                      M.read (| target_jump |),
                                                                      "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                                      "is_jumpdest"
                                                                    |),
                                                                    Value.Bool true
                                                                  |) in
                                                                M.match_operator (|
                                                                  M.alloc (| Value.Tuple [] |),
                                                                  [
                                                                    fun γ =>
                                                                      ltac:(M.monadic
                                                                        (let γ :=
                                                                          M.use
                                                                            (M.alloc (|
                                                                              BinOp.le (|
                                                                                M.read (|
                                                                                  absolute_jump
                                                                                |),
                                                                                M.read (| i |)
                                                                              |)
                                                                            |)) 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 (|
                                                                                        BinOp.ne (|
                                                                                          M.read (|
                                                                                            M.SubPointer.get_struct_record_field (|
                                                                                              M.read (|
                                                                                                target_jump
                                                                                              |),
                                                                                              "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                                                              "biggest"
                                                                                            |)
                                                                                          |),
                                                                                          M.read (|
                                                                                            next_biggest
                                                                                          |)
                                                                                        |)
                                                                                      |)) in
                                                                                  let _ :=
                                                                                    M.is_constant_or_break_match (|
                                                                                      M.read (|
                                                                                        γ
                                                                                      |),
                                                                                      Value.Bool
                                                                                        true
                                                                                    |) in
                                                                                  M.alloc (|
                                                                                    M.never_to_any (|
                                                                                      M.read (|
                                                                                        M.return_ (|
                                                                                          Value.StructTuple
                                                                                            "core::result::Result::Err"
                                                                                            [
                                                                                              Value.StructTuple
                                                                                                "revm_interpreter::interpreter::analysis::EofValidationError::BackwardJumpBiggestNumMismatch"
                                                                                                []
                                                                                            ]
                                                                                        |)
                                                                                      |)
                                                                                    |)
                                                                                  |)));
                                                                              fun γ =>
                                                                                ltac:(M.monadic
                                                                                  (M.alloc (|
                                                                                    Value.Tuple []
                                                                                  |)))
                                                                            ]
                                                                          |) in
                                                                        M.match_operator (|
                                                                          M.alloc (|
                                                                            Value.Tuple []
                                                                          |),
                                                                          [
                                                                            fun γ =>
                                                                              ltac:(M.monadic
                                                                                (let γ :=
                                                                                  M.use
                                                                                    (M.alloc (|
                                                                                      BinOp.ne (|
                                                                                        M.read (|
                                                                                          M.SubPointer.get_struct_record_field (|
                                                                                            M.read (|
                                                                                              target_jump
                                                                                            |),
                                                                                            "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                                                            "smallest"
                                                                                          |)
                                                                                        |),
                                                                                        M.read (|
                                                                                          next_smallest
                                                                                        |)
                                                                                      |)
                                                                                    |)) in
                                                                                let _ :=
                                                                                  M.is_constant_or_break_match (|
                                                                                    M.read (| γ |),
                                                                                    Value.Bool true
                                                                                  |) in
                                                                                M.alloc (|
                                                                                  M.never_to_any (|
                                                                                    M.read (|
                                                                                      M.return_ (|
                                                                                        Value.StructTuple
                                                                                          "core::result::Result::Err"
                                                                                          [
                                                                                            Value.StructTuple
                                                                                              "revm_interpreter::interpreter::analysis::EofValidationError::BackwardJumpSmallestNumMismatch"
                                                                                              []
                                                                                          ]
                                                                                      |)
                                                                                    |)
                                                                                  |)
                                                                                |)));
                                                                            fun γ =>
                                                                              ltac:(M.monadic
                                                                                (M.alloc (|
                                                                                  Value.Tuple []
                                                                                |)))
                                                                          ]
                                                                        |)));
                                                                    fun γ =>
                                                                      ltac:(M.monadic
                                                                        (let~ _ :=
                                                                          M.write (|
                                                                            M.SubPointer.get_struct_record_field (|
                                                                              M.read (|
                                                                                target_jump
                                                                              |),
                                                                              "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                                              "smallest"
                                                                            |),
                                                                            M.call_closure (|
                                                                              M.get_function (|
                                                                                "core::cmp::min",
                                                                                [ Ty.path "i32" ]
                                                                              |),
                                                                              [
                                                                                M.read (|
                                                                                  M.SubPointer.get_struct_record_field (|
                                                                                    M.read (|
                                                                                      target_jump
                                                                                    |),
                                                                                    "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                                                    "smallest"
                                                                                  |)
                                                                                |);
                                                                                M.read (|
                                                                                  next_smallest
                                                                                |)
                                                                              ]
                                                                            |)
                                                                          |) in
                                                                        let~ _ :=
                                                                          M.write (|
                                                                            M.SubPointer.get_struct_record_field (|
                                                                              M.read (|
                                                                                target_jump
                                                                              |),
                                                                              "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                                              "biggest"
                                                                            |),
                                                                            M.call_closure (|
                                                                              M.get_function (|
                                                                                "core::cmp::max",
                                                                                [ Ty.path "i32" ]
                                                                              |),
                                                                              [
                                                                                M.read (|
                                                                                  M.SubPointer.get_struct_record_field (|
                                                                                    M.read (|
                                                                                      target_jump
                                                                                    |),
                                                                                    "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                                                    "biggest"
                                                                                  |)
                                                                                |);
                                                                                M.read (|
                                                                                  next_biggest
                                                                                |)
                                                                              ]
                                                                            |)
                                                                          |) in
                                                                        M.alloc (|
                                                                          Value.Tuple []
                                                                        |)))
                                                                  ]
                                                                |)))
                                                          ]
                                                        |) in
                                                      M.alloc (| Value.Tuple [] |)))
                                                  |)))
                                            ]
                                          |)) in
                                      let~ _ :=
                                        let β := i in
                                        M.write (|
                                          β,
                                          BinOp.Wrap.add (|
                                            M.read (| β |),
                                            BinOp.Wrap.add (|
                                              BinOp.Wrap.add (|
                                                Value.Integer IntegerKind.Usize 1,
                                                M.rust_cast
                                                  (M.call_closure (|
                                                    M.get_associated_function (|
                                                      Ty.path
                                                        "revm_interpreter::opcode::OpCodeInfo",
                                                      "immediate_size",
                                                      []
                                                    |),
                                                    [ M.read (| opcode |) ]
                                                  |))
                                              |),
                                              M.read (| rjumpv_additional_immediates |)
                                            |)
                                          |)
                                        |) in
                                      M.alloc (| Value.Tuple [] |)))
                                ]
                              |)));
                          fun γ =>
                            ltac:(M.monadic
                              (M.alloc (|
                                M.never_to_any (|
                                  M.read (|
                                    let~ _ :=
                                      M.alloc (|
                                        M.never_to_any (| M.read (| M.break (||) |) |)
                                      |) in
                                    M.alloc (| Value.Tuple [] |)
                                  |)
                                |)
                              |)))
                        ]
                      |)))
                  |) in
                let~ _ :=
                  M.match_operator (|
                    M.alloc (| Value.Tuple [] |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ :=
                            M.use
                              (M.alloc (| UnOp.not (| M.read (| is_after_termination |) |) |)) in
                          let _ :=
                            M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                          M.alloc (|
                            M.never_to_any (|
                              M.read (|
                                M.return_ (|
                                  Value.StructTuple
                                    "core::result::Result::Err"
                                    [
                                      Value.StructTuple
                                        "revm_interpreter::interpreter::analysis::EofValidationError::LastInstructionNotTerminating"
                                        []
                                    ]
                                |)
                              |)
                            |)
                          |)));
                      fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                    ]
                  |) in
                let~ max_stack_requirement := M.alloc (| Value.Integer IntegerKind.I32 0 |) 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
                                  "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo";
                                Ty.path "alloc::alloc::Global"
                              ],
                            [],
                            "into_iter",
                            []
                          |),
                          [ M.read (| jumps |) ]
                        |)
                      |),
                      [
                        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
                                                "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo";
                                              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 opcode := M.copy (| γ0_0 |) in
                                          let~ _ :=
                                            M.write (|
                                              max_stack_requirement,
                                              M.call_closure (|
                                                M.get_function (|
                                                  "core::cmp::max",
                                                  [ Ty.path "i32" ]
                                                |),
                                                [
                                                  M.read (|
                                                    M.SubPointer.get_struct_record_field (|
                                                      opcode,
                                                      "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                                      "biggest"
                                                    |)
                                                  |);
                                                  M.read (| max_stack_requirement |)
                                                ]
                                              |)
                                            |) in
                                          M.alloc (| Value.Tuple [] |)))
                                    ]
                                  |) in
                                M.alloc (| Value.Tuple [] |)))
                            |)))
                      ]
                    |)) in
                let~ _ :=
                  M.match_operator (|
                    M.alloc (| Value.Tuple [] |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ :=
                            M.use
                              (M.alloc (|
                                BinOp.ne (|
                                  M.read (| max_stack_requirement |),
                                  M.rust_cast
                                    (M.read (|
                                      M.SubPointer.get_struct_record_field (|
                                        M.SubPointer.get_array_field (|
                                          M.read (| types |),
                                          this_types_index
                                        |),
                                        "revm_primitives::bytecode::eof::types_section::TypesSection",
                                        "max_stack_size"
                                      |)
                                    |))
                                |)
                              |)) in
                          let _ :=
                            M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                          M.alloc (|
                            M.never_to_any (|
                              M.read (|
                                M.return_ (|
                                  Value.StructTuple
                                    "core::result::Result::Err"
                                    [
                                      Value.StructTuple
                                        "revm_interpreter::interpreter::analysis::EofValidationError::MaxStackMismatch"
                                        []
                                    ]
                                |)
                              |)
                            |)
                          |)));
                      fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                    ]
                  |) in
                M.alloc (|
                  Value.StructTuple "core::result::Result::Ok" [ M.read (| accessed_codes |) ]
                |)
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Function_validate_eof_code :
      M.IsFunction "revm_interpreter::interpreter::analysis::validate_eof_code" validate_eof_code.
    
    Module validate_eof_code.
      (* StructRecord
        {
          name := "InstructionInfo";
          const_params := [];
          ty_params := [];
          fields :=
            [
              ("is_immediate", Ty.path "bool");
              ("is_jumpdest", Ty.path "bool");
              ("smallest", Ty.path "i32");
              ("biggest", Ty.path "i32")
            ];
        } *)
      
      Module Impl_core_fmt_Debug_for_revm_interpreter_interpreter_analysis_validate_eof_code_InstructionInfo.
        Definition Self : Ty.t :=
          Ty.path "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo".
        
        (*     Debug *)
        Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
          match ε, τ, α with
          | [], [], [ self; f ] =>
            ltac:(M.monadic
              (let self := M.alloc (| self |) in
              let f := M.alloc (| f |) in
              M.call_closure (|
                M.get_associated_function (|
                  Ty.path "core::fmt::Formatter",
                  "debug_struct_field4_finish",
                  []
                |),
                [
                  M.read (| f |);
                  M.read (| Value.String "InstructionInfo" |);
                  M.read (| Value.String "is_immediate" |);
                  M.SubPointer.get_struct_record_field (|
                    M.read (| self |),
                    "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                    "is_immediate"
                  |);
                  M.read (| Value.String "is_jumpdest" |);
                  M.SubPointer.get_struct_record_field (|
                    M.read (| self |),
                    "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                    "is_jumpdest"
                  |);
                  M.read (| Value.String "smallest" |);
                  M.SubPointer.get_struct_record_field (|
                    M.read (| self |),
                    "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                    "smallest"
                  |);
                  M.read (| Value.String "biggest" |);
                  M.alloc (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                      "biggest"
                    |)
                  |)
                ]
              |)))
          | _, _, _ => M.impossible "wrong number of arguments"
          end.
        
        Axiom Implements :
          M.IsTraitInstance
            "core::fmt::Debug"
            Self
            (* Trait polymorphic types *) []
            (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
      End Impl_core_fmt_Debug_for_revm_interpreter_interpreter_analysis_validate_eof_code_InstructionInfo.
      
      Module Impl_core_marker_Copy_for_revm_interpreter_interpreter_analysis_validate_eof_code_InstructionInfo.
        Definition Self : Ty.t :=
          Ty.path "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo".
        
        Axiom Implements :
          M.IsTraitInstance
            "core::marker::Copy"
            Self
            (* Trait polymorphic types *) []
            (* Instance *) [].
      End Impl_core_marker_Copy_for_revm_interpreter_interpreter_analysis_validate_eof_code_InstructionInfo.
      
      Module Impl_core_clone_Clone_for_revm_interpreter_interpreter_analysis_validate_eof_code_InstructionInfo.
        Definition Self : Ty.t :=
          Ty.path "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo".
        
        (*     Clone *)
        Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
          match ε, τ, α with
          | [], [], [ self ] =>
            ltac:(M.monadic
              (let self := M.alloc (| self |) in
              M.read (|
                M.match_operator (|
                  Value.DeclaredButUndefined,
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (M.match_operator (|
                          Value.DeclaredButUndefined,
                          [ fun γ => ltac:(M.monadic (M.read (| self |))) ]
                        |)))
                  ]
                |)
              |)))
          | _, _, _ => M.impossible "wrong number of arguments"
          end.
        
        Axiom Implements :
          M.IsTraitInstance
            "core::clone::Clone"
            Self
            (* Trait polymorphic types *) []
            (* Instance *) [ ("clone", InstanceField.Method clone) ].
      End Impl_core_clone_Clone_for_revm_interpreter_interpreter_analysis_validate_eof_code_InstructionInfo.
      
      Module Impl_revm_interpreter_interpreter_analysis_validate_eof_code_InstructionInfo.
        Definition Self : Ty.t :=
          Ty.path "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo".
        
        (*
                fn mark_as_immediate(&mut self) -> Result<(), EofValidationError> {
                    if self.is_jumpdest {
                        // Jump to immediate bytes.
                        return Err(EofValidationError::JumpToImmediateBytes);
                    }
                    self.is_immediate = true;
                    Ok(())
                }
        *)
        Definition mark_as_immediate (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
          match ε, τ, α with
          | [], [], [ self ] =>
            ltac:(M.monadic
              (let self := M.alloc (| self |) in
              M.catch_return (|
                ltac:(M.monadic
                  (M.read (|
                    let~ _ :=
                      M.match_operator (|
                        M.alloc (| Value.Tuple [] |),
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let γ :=
                                M.use
                                  (M.SubPointer.get_struct_record_field (|
                                    M.read (| self |),
                                    "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                                    "is_jumpdest"
                                  |)) in
                              let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ |),
                                  Value.Bool true
                                |) in
                              M.alloc (|
                                M.never_to_any (|
                                  M.read (|
                                    M.return_ (|
                                      Value.StructTuple
                                        "core::result::Result::Err"
                                        [
                                          Value.StructTuple
                                            "revm_interpreter::interpreter::analysis::EofValidationError::JumpToImmediateBytes"
                                            []
                                        ]
                                    |)
                                  |)
                                |)
                              |)));
                          fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                        ]
                      |) in
                    let~ _ :=
                      M.write (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo",
                          "is_immediate"
                        |),
                        Value.Bool true
                      |) in
                    M.alloc (| Value.StructTuple "core::result::Result::Ok" [ Value.Tuple [] ] |)
                  |)))
              |)))
          | _, _, _ => M.impossible "wrong number of arguments"
          end.
        
        Axiom AssociatedFunction_mark_as_immediate :
          M.IsAssociatedFunction Self "mark_as_immediate" mark_as_immediate.
      End Impl_revm_interpreter_interpreter_analysis_validate_eof_code_InstructionInfo.
      
      Module Impl_core_default_Default_for_revm_interpreter_interpreter_analysis_validate_eof_code_InstructionInfo.
        Definition Self : Ty.t :=
          Ty.path "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo".
        
        (*
                fn default() -> Self {
                    Self {
                        is_immediate: false,
                        is_jumpdest: false,
                        smallest: i32::MAX,
                        biggest: i32::MIN,
                    }
                }
        *)
        Definition default (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
          match ε, τ, α with
          | [], [], [] =>
            ltac:(M.monadic
              (Value.StructRecord
                "revm_interpreter::interpreter::analysis::validate_eof_code::InstructionInfo"
                [
                  ("is_immediate", Value.Bool false);
                  ("is_jumpdest", Value.Bool false);
                  ("smallest", M.read (| M.get_constant (| "core::num::MAX" |) |));
                  ("biggest", M.read (| M.get_constant (| "core::num::MIN" |) |))
                ]))
          | _, _, _ => M.impossible "wrong number of arguments"
          end.
        
        Axiom Implements :
          M.IsTraitInstance
            "core::default::Default"
            Self
            (* Trait polymorphic types *) []
            (* Instance *) [ ("default", InstanceField.Method default) ].
      End Impl_core_default_Default_for_revm_interpreter_interpreter_analysis_validate_eof_code_InstructionInfo.
    End validate_eof_code.
  End analysis.
End interpreter.
