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

Module interpreter_action.
  Module call_inputs.
    (* StructRecord
      {
        name := "CallInputs";
        const_params := [];
        ty_params := [];
        fields :=
          [
            ("input", Ty.path "alloy_primitives::bytes_::Bytes");
            ("return_memory_offset",
              Ty.apply (Ty.path "core::ops::range::Range") [] [ Ty.path "usize" ]);
            ("gas_limit", Ty.path "u64");
            ("bytecode_address", Ty.path "alloy_primitives::bits::address::Address");
            ("target_address", Ty.path "alloy_primitives::bits::address::Address");
            ("caller", Ty.path "alloy_primitives::bits::address::Address");
            ("value", Ty.path "revm_interpreter::interpreter_action::call_inputs::CallValue");
            ("scheme", Ty.path "revm_interpreter::interpreter_action::call_inputs::CallScheme");
            ("is_static", Ty.path "bool");
            ("is_eof", Ty.path "bool")
          ];
      } *)
    
    Module Impl_core_clone_Clone_for_revm_interpreter_interpreter_action_call_inputs_CallInputs.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallInputs".
      
      (* Clone *)
      Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            Value.StructRecord
              "revm_interpreter::interpreter_action::call_inputs::CallInputs"
              [
                ("input",
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::clone::Clone",
                      Ty.path "alloy_primitives::bytes_::Bytes",
                      [],
                      "clone",
                      []
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                        "input"
                      |)
                    ]
                  |));
                ("return_memory_offset",
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::clone::Clone",
                      Ty.apply (Ty.path "core::ops::range::Range") [] [ Ty.path "usize" ],
                      [],
                      "clone",
                      []
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                        "return_memory_offset"
                      |)
                    ]
                  |));
                ("gas_limit",
                  M.call_closure (|
                    M.get_trait_method (| "core::clone::Clone", Ty.path "u64", [], "clone", [] |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                        "gas_limit"
                      |)
                    ]
                  |));
                ("bytecode_address",
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::clone::Clone",
                      Ty.path "alloy_primitives::bits::address::Address",
                      [],
                      "clone",
                      []
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                        "bytecode_address"
                      |)
                    ]
                  |));
                ("target_address",
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::clone::Clone",
                      Ty.path "alloy_primitives::bits::address::Address",
                      [],
                      "clone",
                      []
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                        "target_address"
                      |)
                    ]
                  |));
                ("caller",
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::clone::Clone",
                      Ty.path "alloy_primitives::bits::address::Address",
                      [],
                      "clone",
                      []
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                        "caller"
                      |)
                    ]
                  |));
                ("value",
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::clone::Clone",
                      Ty.path "revm_interpreter::interpreter_action::call_inputs::CallValue",
                      [],
                      "clone",
                      []
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                        "value"
                      |)
                    ]
                  |));
                ("scheme",
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::clone::Clone",
                      Ty.path "revm_interpreter::interpreter_action::call_inputs::CallScheme",
                      [],
                      "clone",
                      []
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                        "scheme"
                      |)
                    ]
                  |));
                ("is_static",
                  M.call_closure (|
                    M.get_trait_method (| "core::clone::Clone", Ty.path "bool", [], "clone", [] |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                        "is_static"
                      |)
                    ]
                  |));
                ("is_eof",
                  M.call_closure (|
                    M.get_trait_method (| "core::clone::Clone", Ty.path "bool", [], "clone", [] |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                        "is_eof"
                      |)
                    ]
                  |))
              ]))
        | _, _, _ => 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_action_call_inputs_CallInputs.
    
    Module Impl_core_fmt_Debug_for_revm_interpreter_interpreter_action_call_inputs_CallInputs.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallInputs".
      
      (* 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 (|
              let~ names :=
                M.alloc (|
                  M.alloc (|
                    Value.Array
                      [
                        M.read (| Value.String "input" |);
                        M.read (| Value.String "return_memory_offset" |);
                        M.read (| Value.String "gas_limit" |);
                        M.read (| Value.String "bytecode_address" |);
                        M.read (| Value.String "target_address" |);
                        M.read (| Value.String "caller" |);
                        M.read (| Value.String "value" |);
                        M.read (| Value.String "scheme" |);
                        M.read (| Value.String "is_static" |);
                        M.read (| Value.String "is_eof" |)
                      ]
                  |)
                |) in
              let~ values :=
                M.alloc (|
                  M.alloc (|
                    Value.Array
                      [
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                          "input"
                        |);
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                          "return_memory_offset"
                        |);
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                          "gas_limit"
                        |);
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                          "bytecode_address"
                        |);
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                          "target_address"
                        |);
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                          "caller"
                        |);
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                          "value"
                        |);
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                          "scheme"
                        |);
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                          "is_static"
                        |);
                        M.alloc (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| self |),
                            "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                            "is_eof"
                          |)
                        |)
                      ]
                  |)
                |) in
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.path "core::fmt::Formatter",
                    "debug_struct_fields_finish",
                    []
                  |),
                  [
                    M.read (| f |);
                    M.read (| Value.String "CallInputs" |);
                    M.read (| names |);
                    M.read (| values |)
                  ]
                |)
              |)
            |)))
        | _, _, _ => 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_action_call_inputs_CallInputs.
    
    Module Impl_core_marker_StructuralPartialEq_for_revm_interpreter_interpreter_action_call_inputs_CallInputs.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallInputs".
      
      Axiom Implements :
        M.IsTraitInstance
          "core::marker::StructuralPartialEq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_marker_StructuralPartialEq_for_revm_interpreter_interpreter_action_call_inputs_CallInputs.
    
    Module Impl_core_cmp_PartialEq_for_revm_interpreter_interpreter_action_call_inputs_CallInputs.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallInputs".
      
      (* 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
            LogicalOp.and (|
              LogicalOp.and (|
                LogicalOp.and (|
                  LogicalOp.and (|
                    LogicalOp.and (|
                      LogicalOp.and (|
                        LogicalOp.and (|
                          LogicalOp.and (|
                            LogicalOp.and (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.path "alloy_primitives::bytes_::Bytes",
                                  [ Ty.path "alloy_primitives::bytes_::Bytes" ],
                                  "eq",
                                  []
                                |),
                                [
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| self |),
                                    "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                                    "input"
                                  |);
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| other |),
                                    "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                                    "input"
                                  |)
                                ]
                              |),
                              ltac:(M.monadic
                                (M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialEq",
                                    Ty.apply
                                      (Ty.path "core::ops::range::Range")
                                      []
                                      [ Ty.path "usize" ],
                                    [
                                      Ty.apply
                                        (Ty.path "core::ops::range::Range")
                                        []
                                        [ Ty.path "usize" ]
                                    ],
                                    "eq",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| self |),
                                      "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                                      "return_memory_offset"
                                    |);
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| other |),
                                      "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                                      "return_memory_offset"
                                    |)
                                  ]
                                |)))
                            |),
                            ltac:(M.monadic
                              (BinOp.eq (|
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| self |),
                                    "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                                    "gas_limit"
                                  |)
                                |),
                                M.read (|
                                  M.SubPointer.get_struct_record_field (|
                                    M.read (| other |),
                                    "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                                    "gas_limit"
                                  |)
                                |)
                              |)))
                          |),
                          ltac:(M.monadic
                            (M.call_closure (|
                              M.get_trait_method (|
                                "core::cmp::PartialEq",
                                Ty.path "alloy_primitives::bits::address::Address",
                                [ Ty.path "alloy_primitives::bits::address::Address" ],
                                "eq",
                                []
                              |),
                              [
                                M.SubPointer.get_struct_record_field (|
                                  M.read (| self |),
                                  "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                                  "bytecode_address"
                                |);
                                M.SubPointer.get_struct_record_field (|
                                  M.read (| other |),
                                  "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                                  "bytecode_address"
                                |)
                              ]
                            |)))
                        |),
                        ltac:(M.monadic
                          (M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.path "alloy_primitives::bits::address::Address",
                              [ Ty.path "alloy_primitives::bits::address::Address" ],
                              "eq",
                              []
                            |),
                            [
                              M.SubPointer.get_struct_record_field (|
                                M.read (| self |),
                                "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                                "target_address"
                              |);
                              M.SubPointer.get_struct_record_field (|
                                M.read (| other |),
                                "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                                "target_address"
                              |)
                            ]
                          |)))
                      |),
                      ltac:(M.monadic
                        (M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialEq",
                            Ty.path "alloy_primitives::bits::address::Address",
                            [ Ty.path "alloy_primitives::bits::address::Address" ],
                            "eq",
                            []
                          |),
                          [
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                              "caller"
                            |);
                            M.SubPointer.get_struct_record_field (|
                              M.read (| other |),
                              "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                              "caller"
                            |)
                          ]
                        |)))
                    |),
                    ltac:(M.monadic
                      (M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.path "revm_interpreter::interpreter_action::call_inputs::CallValue",
                          [ Ty.path "revm_interpreter::interpreter_action::call_inputs::CallValue"
                          ],
                          "eq",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            M.read (| self |),
                            "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                            "value"
                          |);
                          M.SubPointer.get_struct_record_field (|
                            M.read (| other |),
                            "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                            "value"
                          |)
                        ]
                      |)))
                  |),
                  ltac:(M.monadic
                    (M.call_closure (|
                      M.get_trait_method (|
                        "core::cmp::PartialEq",
                        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallScheme",
                        [ Ty.path "revm_interpreter::interpreter_action::call_inputs::CallScheme" ],
                        "eq",
                        []
                      |),
                      [
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                          "scheme"
                        |);
                        M.SubPointer.get_struct_record_field (|
                          M.read (| other |),
                          "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                          "scheme"
                        |)
                      ]
                    |)))
                |),
                ltac:(M.monadic
                  (BinOp.eq (|
                    M.read (|
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                        "is_static"
                      |)
                    |),
                    M.read (|
                      M.SubPointer.get_struct_record_field (|
                        M.read (| other |),
                        "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                        "is_static"
                      |)
                    |)
                  |)))
              |),
              ltac:(M.monadic
                (BinOp.eq (|
                  M.read (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                      "is_eof"
                    |)
                  |),
                  M.read (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| other |),
                      "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                      "is_eof"
                    |)
                  |)
                |)))
            |)))
        | _, _, _ => 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_action_call_inputs_CallInputs.
    
    Module Impl_core_cmp_Eq_for_revm_interpreter_interpreter_action_call_inputs_CallInputs.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallInputs".
      
      (* Eq *)
      Definition assert_receiver_is_total_eq
          (ε : list Value.t)
          (τ : list Ty.t)
          (α : list Value.t)
          : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.read (|
              M.match_operator (|
                Value.DeclaredButUndefined,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (M.match_operator (|
                        Value.DeclaredButUndefined,
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (M.match_operator (|
                                Value.DeclaredButUndefined,
                                [
                                  fun γ =>
                                    ltac:(M.monadic
                                      (M.match_operator (|
                                        Value.DeclaredButUndefined,
                                        [
                                          fun γ =>
                                            ltac:(M.monadic
                                              (M.match_operator (|
                                                Value.DeclaredButUndefined,
                                                [
                                                  fun γ =>
                                                    ltac:(M.monadic
                                                      (M.match_operator (|
                                                        Value.DeclaredButUndefined,
                                                        [
                                                          fun γ =>
                                                            ltac:(M.monadic
                                                              (M.match_operator (|
                                                                Value.DeclaredButUndefined,
                                                                [
                                                                  fun γ =>
                                                                    ltac:(M.monadic
                                                                      (M.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_action_call_inputs_CallInputs.
    
    Module Impl_core_hash_Hash_for_revm_interpreter_interpreter_action_call_inputs_CallInputs.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallInputs".
      
      (* 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~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::hash::Hash",
                      Ty.path "alloy_primitives::bytes_::Bytes",
                      [],
                      "hash",
                      [ __H ]
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                        "input"
                      |);
                      M.read (| state |)
                    ]
                  |)
                |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::hash::Hash",
                      Ty.apply (Ty.path "core::ops::range::Range") [] [ Ty.path "usize" ],
                      [],
                      "hash",
                      [ __H ]
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                        "return_memory_offset"
                      |);
                      M.read (| state |)
                    ]
                  |)
                |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (| "core::hash::Hash", Ty.path "u64", [], "hash", [ __H ] |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                        "gas_limit"
                      |);
                      M.read (| state |)
                    ]
                  |)
                |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::hash::Hash",
                      Ty.path "alloy_primitives::bits::address::Address",
                      [],
                      "hash",
                      [ __H ]
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                        "bytecode_address"
                      |);
                      M.read (| state |)
                    ]
                  |)
                |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::hash::Hash",
                      Ty.path "alloy_primitives::bits::address::Address",
                      [],
                      "hash",
                      [ __H ]
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                        "target_address"
                      |);
                      M.read (| state |)
                    ]
                  |)
                |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::hash::Hash",
                      Ty.path "alloy_primitives::bits::address::Address",
                      [],
                      "hash",
                      [ __H ]
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                        "caller"
                      |);
                      M.read (| state |)
                    ]
                  |)
                |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::hash::Hash",
                      Ty.path "revm_interpreter::interpreter_action::call_inputs::CallValue",
                      [],
                      "hash",
                      [ __H ]
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                        "value"
                      |);
                      M.read (| state |)
                    ]
                  |)
                |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::hash::Hash",
                      Ty.path "revm_interpreter::interpreter_action::call_inputs::CallScheme",
                      [],
                      "hash",
                      [ __H ]
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                        "scheme"
                      |);
                      M.read (| state |)
                    ]
                  |)
                |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::hash::Hash",
                      Ty.path "bool",
                      [],
                      "hash",
                      [ __H ]
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                        "is_static"
                      |);
                      M.read (| state |)
                    ]
                  |)
                |) in
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::hash::Hash", Ty.path "bool", [], "hash", [ __H ] |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                      "is_eof"
                    |);
                    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_action_call_inputs_CallInputs.
    
    Module Impl_revm_interpreter_interpreter_action_call_inputs_CallInputs.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallInputs".
      
      (*
          pub fn new(tx_env: &TxEnv, gas_limit: u64) -> Option<Self> {
              let TransactTo::Call(target_address) = tx_env.transact_to else {
                  return None;
              };
              Some(CallInputs {
                  input: tx_env.data.clone(),
                  gas_limit,
                  target_address,
                  bytecode_address: target_address,
                  caller: tx_env.caller,
                  value: CallValue::Transfer(tx_env.value),
                  scheme: CallScheme::Call,
                  is_static: false,
                  is_eof: false,
                  return_memory_offset: 0..0,
              })
          }
      *)
      Definition new (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ tx_env; gas_limit ] =>
          ltac:(M.monadic
            (let tx_env := M.alloc (| tx_env |) in
            let gas_limit := M.alloc (| gas_limit |) in
            M.read (|
              M.match_operator (|
                M.SubPointer.get_struct_record_field (|
                  M.read (| tx_env |),
                  "revm_primitives::env::TxEnv",
                  "transact_to"
                |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "revm_primitives::env::TransactTo::Call",
                          0
                        |) in
                      let target_address := M.copy (| γ0_0 |) in
                      M.alloc (|
                        Value.StructTuple
                          "core::option::Option::Some"
                          [
                            Value.StructRecord
                              "revm_interpreter::interpreter_action::call_inputs::CallInputs"
                              [
                                ("input",
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::clone::Clone",
                                      Ty.path "alloy_primitives::bytes_::Bytes",
                                      [],
                                      "clone",
                                      []
                                    |),
                                    [
                                      M.SubPointer.get_struct_record_field (|
                                        M.read (| tx_env |),
                                        "revm_primitives::env::TxEnv",
                                        "data"
                                      |)
                                    ]
                                  |));
                                ("gas_limit", M.read (| gas_limit |));
                                ("target_address", M.read (| target_address |));
                                ("bytecode_address", M.read (| target_address |));
                                ("caller",
                                  M.read (|
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| tx_env |),
                                      "revm_primitives::env::TxEnv",
                                      "caller"
                                    |)
                                  |));
                                ("value",
                                  Value.StructTuple
                                    "revm_interpreter::interpreter_action::call_inputs::CallValue::Transfer"
                                    [
                                      M.read (|
                                        M.SubPointer.get_struct_record_field (|
                                          M.read (| tx_env |),
                                          "revm_primitives::env::TxEnv",
                                          "value"
                                        |)
                                      |)
                                    ]);
                                ("scheme",
                                  Value.StructTuple
                                    "revm_interpreter::interpreter_action::call_inputs::CallScheme::Call"
                                    []);
                                ("is_static", Value.Bool false);
                                ("is_eof", Value.Bool false);
                                ("return_memory_offset",
                                  Value.StructRecord
                                    "core::ops::range::Range"
                                    [
                                      ("start", Value.Integer IntegerKind.Usize 0);
                                      ("end_", Value.Integer IntegerKind.Usize 0)
                                    ])
                              ]
                          ]
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_new : M.IsAssociatedFunction Self "new" new.
      
      (*
          pub fn new_boxed(tx_env: &TxEnv, gas_limit: u64) -> Option<Box<Self>> {
              Self::new(tx_env, gas_limit).map(Box::new)
          }
      *)
      Definition new_boxed (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ tx_env; gas_limit ] =>
          ltac:(M.monadic
            (let tx_env := M.alloc (| tx_env |) in
            let gas_limit := M.alloc (| gas_limit |) in
            M.call_closure (|
              M.get_associated_function (|
                Ty.apply
                  (Ty.path "core::option::Option")
                  []
                  [ Ty.path "revm_interpreter::interpreter_action::call_inputs::CallInputs" ],
                "map",
                [
                  Ty.apply
                    (Ty.path "alloc::boxed::Box")
                    []
                    [
                      Ty.path "revm_interpreter::interpreter_action::call_inputs::CallInputs";
                      Ty.path "alloc::alloc::Global"
                    ];
                  Ty.function
                    [ Ty.path "revm_interpreter::interpreter_action::call_inputs::CallInputs" ]
                    (Ty.apply
                      (Ty.path "alloc::boxed::Box")
                      []
                      [
                        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallInputs";
                        Ty.path "alloc::alloc::Global"
                      ])
                ]
              |),
              [
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.path "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                    "new",
                    []
                  |),
                  [ M.read (| tx_env |); M.read (| gas_limit |) ]
                |);
                M.get_associated_function (|
                  Ty.apply
                    (Ty.path "alloc::boxed::Box")
                    []
                    [
                      Ty.path "revm_interpreter::interpreter_action::call_inputs::CallInputs";
                      Ty.path "alloc::alloc::Global"
                    ],
                  "new",
                  []
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_new_boxed : M.IsAssociatedFunction Self "new_boxed" new_boxed.
      
      (*
          pub fn transfers_value(&self) -> bool {
              self.value.transfer().is_some_and(|x| x > U256::ZERO)
          }
      *)
      Definition transfers_value (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_associated_function (|
                Ty.apply
                  (Ty.path "core::option::Option")
                  []
                  [
                    Ty.apply
                      (Ty.path "ruint::Uint")
                      [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ]
                      []
                  ],
                "is_some_and",
                [
                  Ty.function
                    [
                      Ty.tuple
                        [
                          Ty.apply
                            (Ty.path "ruint::Uint")
                            [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4
                            ]
                            []
                        ]
                    ]
                    (Ty.path "bool")
                ]
              |),
              [
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.path "revm_interpreter::interpreter_action::call_inputs::CallValue",
                    "transfer",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                      "value"
                    |)
                  ]
                |);
                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
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialOrd",
                                      Ty.apply
                                        (Ty.path "ruint::Uint")
                                        [
                                          Value.Integer IntegerKind.Usize 256;
                                          Value.Integer IntegerKind.Usize 4
                                        ]
                                        [],
                                      [
                                        Ty.apply
                                          (Ty.path "ruint::Uint")
                                          [
                                            Value.Integer IntegerKind.Usize 256;
                                            Value.Integer IntegerKind.Usize 4
                                          ]
                                          []
                                      ],
                                      "gt",
                                      []
                                    |),
                                    [ x; M.get_constant (| "ruint::ZERO" |) ]
                                  |)))
                            ]
                          |)))
                      | _ => M.impossible "wrong number of arguments"
                      end))
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_transfers_value :
        M.IsAssociatedFunction Self "transfers_value" transfers_value.
      
      (*
          pub const fn transfer_value(&self) -> Option<U256> {
              self.value.transfer()
          }
      *)
      Definition transfer_value (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_associated_function (|
                Ty.path "revm_interpreter::interpreter_action::call_inputs::CallValue",
                "transfer",
                []
              |),
              [
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                  "value"
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_transfer_value :
        M.IsAssociatedFunction Self "transfer_value" transfer_value.
      
      (*
          pub const fn apparent_value(&self) -> Option<U256> {
              self.value.apparent()
          }
      *)
      Definition apparent_value (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_associated_function (|
                Ty.path "revm_interpreter::interpreter_action::call_inputs::CallValue",
                "apparent",
                []
              |),
              [
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                  "value"
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_apparent_value :
        M.IsAssociatedFunction Self "apparent_value" apparent_value.
      
      (*
          pub const fn transfer_from(&self) -> Address {
              self.caller
          }
      *)
      Definition transfer_from (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.read (|
              M.SubPointer.get_struct_record_field (|
                M.read (| self |),
                "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                "caller"
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_transfer_from :
        M.IsAssociatedFunction Self "transfer_from" transfer_from.
      
      (*
          pub const fn transfer_to(&self) -> Address {
              self.target_address
          }
      *)
      Definition transfer_to (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.read (|
              M.SubPointer.get_struct_record_field (|
                M.read (| self |),
                "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                "target_address"
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_transfer_to : M.IsAssociatedFunction Self "transfer_to" transfer_to.
      
      (*
          pub const fn call_value(&self) -> U256 {
              self.value.get()
          }
      *)
      Definition call_value (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_associated_function (|
                Ty.path "revm_interpreter::interpreter_action::call_inputs::CallValue",
                "get",
                []
              |),
              [
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "revm_interpreter::interpreter_action::call_inputs::CallInputs",
                  "value"
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_call_value : M.IsAssociatedFunction Self "call_value" call_value.
    End Impl_revm_interpreter_interpreter_action_call_inputs_CallInputs.
    
    (*
    Enum CallScheme
    {
      const_params := [];
      ty_params := [];
      variants :=
        [
          {
            name := "Call";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "CallCode";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "DelegateCall";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "StaticCall";
            item := StructTuple [];
            discriminant := None;
          }
        ];
    }
    *)
    
    Module Impl_core_clone_Clone_for_revm_interpreter_interpreter_action_call_inputs_CallScheme.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallScheme".
      
      (* 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_action_call_inputs_CallScheme.
    
    Module Impl_core_marker_Copy_for_revm_interpreter_interpreter_action_call_inputs_CallScheme.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallScheme".
      
      Axiom Implements :
        M.IsTraitInstance
          "core::marker::Copy"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_marker_Copy_for_revm_interpreter_interpreter_action_call_inputs_CallScheme.
    
    Module Impl_core_fmt_Debug_for_revm_interpreter_interpreter_action_call_inputs_CallScheme.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallScheme".
      
      (* 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_action::call_inputs::CallScheme::Call"
                            |) in
                          M.alloc (| M.read (| Value.String "Call" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter_action::call_inputs::CallScheme::CallCode"
                            |) in
                          M.alloc (| M.read (| Value.String "CallCode" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter_action::call_inputs::CallScheme::DelegateCall"
                            |) in
                          M.alloc (| M.read (| Value.String "DelegateCall" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "revm_interpreter::interpreter_action::call_inputs::CallScheme::StaticCall"
                            |) in
                          M.alloc (| M.read (| Value.String "StaticCall" |) |)))
                    ]
                  |)
                |)
              ]
            |)))
        | _, _, _ => 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_action_call_inputs_CallScheme.
    
    Module Impl_core_marker_StructuralPartialEq_for_revm_interpreter_interpreter_action_call_inputs_CallScheme.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallScheme".
      
      Axiom Implements :
        M.IsTraitInstance
          "core::marker::StructuralPartialEq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_marker_StructuralPartialEq_for_revm_interpreter_interpreter_action_call_inputs_CallScheme.
    
    Module Impl_core_cmp_PartialEq_for_revm_interpreter_interpreter_action_call_inputs_CallScheme.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallScheme".
      
      (* 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_action::call_inputs::CallScheme" ]
                    |),
                    [ M.read (| self |) ]
                  |)
                |) in
              let~ __arg1_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "revm_interpreter::interpreter_action::call_inputs::CallScheme" ]
                    |),
                    [ 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_action_call_inputs_CallScheme.
    
    Module Impl_core_cmp_Eq_for_revm_interpreter_interpreter_action_call_inputs_CallScheme.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallScheme".
      
      (* 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_action_call_inputs_CallScheme.
    
    Module Impl_core_hash_Hash_for_revm_interpreter_interpreter_action_call_inputs_CallScheme.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallScheme".
      
      (* 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_action::call_inputs::CallScheme" ]
                    |),
                    [ 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_action_call_inputs_CallScheme.
    
    (*
    Enum CallValue
    {
      const_params := [];
      ty_params := [];
      variants :=
        [
          {
            name := "Transfer";
            item :=
              StructTuple
                [
                  Ty.apply
                    (Ty.path "ruint::Uint")
                    [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ]
                    []
                ];
            discriminant := None;
          };
          {
            name := "Apparent";
            item :=
              StructTuple
                [
                  Ty.apply
                    (Ty.path "ruint::Uint")
                    [ Value.Integer IntegerKind.Usize 256; Value.Integer IntegerKind.Usize 4 ]
                    []
                ];
            discriminant := None;
          }
        ];
    }
    *)
    
    Module Impl_core_clone_Clone_for_revm_interpreter_interpreter_action_call_inputs_CallValue.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallValue".
      
      (* Clone *)
      Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.read (|
              M.match_operator (|
                self,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "revm_interpreter::interpreter_action::call_inputs::CallValue::Transfer",
                          0
                        |) in
                      let __self_0 := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        Value.StructTuple
                          "revm_interpreter::interpreter_action::call_inputs::CallValue::Transfer"
                          [
                            M.call_closure (|
                              M.get_trait_method (|
                                "core::clone::Clone",
                                Ty.apply
                                  (Ty.path "ruint::Uint")
                                  [
                                    Value.Integer IntegerKind.Usize 256;
                                    Value.Integer IntegerKind.Usize 4
                                  ]
                                  [],
                                [],
                                "clone",
                                []
                              |),
                              [ M.read (| __self_0 |) ]
                            |)
                          ]
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "revm_interpreter::interpreter_action::call_inputs::CallValue::Apparent",
                          0
                        |) in
                      let __self_0 := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        Value.StructTuple
                          "revm_interpreter::interpreter_action::call_inputs::CallValue::Apparent"
                          [
                            M.call_closure (|
                              M.get_trait_method (|
                                "core::clone::Clone",
                                Ty.apply
                                  (Ty.path "ruint::Uint")
                                  [
                                    Value.Integer IntegerKind.Usize 256;
                                    Value.Integer IntegerKind.Usize 4
                                  ]
                                  [],
                                [],
                                "clone",
                                []
                              |),
                              [ M.read (| __self_0 |) ]
                            |)
                          ]
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::clone::Clone"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("clone", InstanceField.Method clone) ].
    End Impl_core_clone_Clone_for_revm_interpreter_interpreter_action_call_inputs_CallValue.
    
    Module Impl_core_fmt_Debug_for_revm_interpreter_interpreter_action_call_inputs_CallValue.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallValue".
      
      (* 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_action::call_inputs::CallValue::Transfer",
                          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 "Transfer" |); __self_0 ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "revm_interpreter::interpreter_action::call_inputs::CallValue::Apparent",
                          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 "Apparent" |); __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_action_call_inputs_CallValue.
    
    Module Impl_core_marker_StructuralPartialEq_for_revm_interpreter_interpreter_action_call_inputs_CallValue.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallValue".
      
      Axiom Implements :
        M.IsTraitInstance
          "core::marker::StructuralPartialEq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_marker_StructuralPartialEq_for_revm_interpreter_interpreter_action_call_inputs_CallValue.
    
    Module Impl_core_cmp_PartialEq_for_revm_interpreter_interpreter_action_call_inputs_CallValue.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallValue".
      
      (* 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_action::call_inputs::CallValue" ]
                    |),
                    [ M.read (| self |) ]
                  |)
                |) in
              let~ __arg1_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "revm_interpreter::interpreter_action::call_inputs::CallValue" ]
                    |),
                    [ 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_action::call_inputs::CallValue::Transfer",
                                  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_action::call_inputs::CallValue::Transfer",
                                  0
                                |) in
                              let __arg1_0 := M.alloc (| γ2_0 |) in
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialEq",
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [
                                        Ty.apply
                                          (Ty.path "ruint::Uint")
                                          [
                                            Value.Integer IntegerKind.Usize 256;
                                            Value.Integer IntegerKind.Usize 4
                                          ]
                                          []
                                      ],
                                    [
                                      Ty.apply
                                        (Ty.path "&")
                                        []
                                        [
                                          Ty.apply
                                            (Ty.path "ruint::Uint")
                                            [
                                              Value.Integer IntegerKind.Usize 256;
                                              Value.Integer IntegerKind.Usize 4
                                            ]
                                            []
                                        ]
                                    ],
                                    "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_action::call_inputs::CallValue::Apparent",
                                  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_action::call_inputs::CallValue::Apparent",
                                  0
                                |) in
                              let __arg1_0 := M.alloc (| γ2_0 |) in
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialEq",
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [
                                        Ty.apply
                                          (Ty.path "ruint::Uint")
                                          [
                                            Value.Integer IntegerKind.Usize 256;
                                            Value.Integer IntegerKind.Usize 4
                                          ]
                                          []
                                      ],
                                    [
                                      Ty.apply
                                        (Ty.path "&")
                                        []
                                        [
                                          Ty.apply
                                            (Ty.path "ruint::Uint")
                                            [
                                              Value.Integer IntegerKind.Usize 256;
                                              Value.Integer IntegerKind.Usize 4
                                            ]
                                            []
                                        ]
                                    ],
                                    "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_action_call_inputs_CallValue.
    
    Module Impl_core_cmp_Eq_for_revm_interpreter_interpreter_action_call_inputs_CallValue.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallValue".
      
      (* Eq *)
      Definition assert_receiver_is_total_eq
          (ε : list Value.t)
          (τ : list Ty.t)
          (α : list Value.t)
          : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.read (|
              M.match_operator (|
                Value.DeclaredButUndefined,
                [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::Eq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ].
    End Impl_core_cmp_Eq_for_revm_interpreter_interpreter_action_call_inputs_CallValue.
    
    Module Impl_core_hash_Hash_for_revm_interpreter_interpreter_action_call_inputs_CallValue.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallValue".
      
      (* 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_action::call_inputs::CallValue" ]
                    |),
                    [ 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_action::call_inputs::CallValue::Transfer",
                          0
                        |) in
                      let __self_0 := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::hash::Hash",
                            Ty.apply
                              (Ty.path "ruint::Uint")
                              [
                                Value.Integer IntegerKind.Usize 256;
                                Value.Integer IntegerKind.Usize 4
                              ]
                              [],
                            [],
                            "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_action::call_inputs::CallValue::Apparent",
                          0
                        |) in
                      let __self_0 := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::hash::Hash",
                            Ty.apply
                              (Ty.path "ruint::Uint")
                              [
                                Value.Integer IntegerKind.Usize 256;
                                Value.Integer IntegerKind.Usize 4
                              ]
                              [],
                            [],
                            "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_action_call_inputs_CallValue.
    
    Module Impl_core_default_Default_for_revm_interpreter_interpreter_action_call_inputs_CallValue.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallValue".
      
      (*
          fn default() -> Self {
              CallValue::Transfer(U256::ZERO)
          }
      *)
      Definition default (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [] =>
          ltac:(M.monadic
            (Value.StructTuple
              "revm_interpreter::interpreter_action::call_inputs::CallValue::Transfer"
              [ M.read (| M.get_constant (| "ruint::ZERO" |) |) ]))
        | _, _, _ => 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_action_call_inputs_CallValue.
    
    Module Impl_revm_interpreter_interpreter_action_call_inputs_CallValue.
      Definition Self : Ty.t :=
        Ty.path "revm_interpreter::interpreter_action::call_inputs::CallValue".
      
      (*
          pub const fn get(&self) -> U256 {
              match *self {
                  Self::Transfer(value) | Self::Apparent(value) => value,
              }
          }
      *)
      Definition get (ε : 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 (|
                M.read (| self |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (M.find_or_pattern (|
                        γ,
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ,
                                  "revm_interpreter::interpreter_action::call_inputs::CallValue::Transfer",
                                  0
                                |) in
                              let value := M.copy (| γ0_0 |) in
                              Value.Tuple [ value ]));
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ,
                                  "revm_interpreter::interpreter_action::call_inputs::CallValue::Apparent",
                                  0
                                |) in
                              let value := M.copy (| γ0_0 |) in
                              Value.Tuple [ value ]))
                        ],
                        M.closure
                          (fun γ =>
                            ltac:(M.monadic
                              match γ with
                              | [ value ] => ltac:(M.monadic value)
                              | _ => M.impossible "wrong number of arguments"
                              end))
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_get : M.IsAssociatedFunction Self "get" get.
      
      (*
          pub const fn transfer(&self) -> Option<U256> {
              match *self {
                  Self::Transfer(transfer) => Some(transfer),
                  Self::Apparent(_) => None,
              }
          }
      *)
      Definition transfer (ε : 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 (|
                M.read (| self |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "revm_interpreter::interpreter_action::call_inputs::CallValue::Transfer",
                          0
                        |) in
                      let transfer := M.copy (| γ0_0 |) in
                      M.alloc (|
                        Value.StructTuple "core::option::Option::Some" [ M.read (| transfer |) ]
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "revm_interpreter::interpreter_action::call_inputs::CallValue::Apparent",
                          0
                        |) in
                      M.alloc (| Value.StructTuple "core::option::Option::None" [] |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_transfer : M.IsAssociatedFunction Self "transfer" transfer.
      
      (*
          pub const fn is_transfer(&self) -> bool {
              matches!(self, Self::Transfer(_))
          }
      *)
      Definition is_transfer (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.read (|
              M.match_operator (|
                self,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "revm_interpreter::interpreter_action::call_inputs::CallValue::Transfer",
                          0
                        |) in
                      M.alloc (| Value.Bool true |)));
                  fun γ => ltac:(M.monadic (M.alloc (| Value.Bool false |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_transfer : M.IsAssociatedFunction Self "is_transfer" is_transfer.
      
      (*
          pub const fn apparent(&self) -> Option<U256> {
              match *self {
                  Self::Transfer(_) => None,
                  Self::Apparent(apparent) => Some(apparent),
              }
          }
      *)
      Definition apparent (ε : 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 (|
                M.read (| self |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "revm_interpreter::interpreter_action::call_inputs::CallValue::Transfer",
                          0
                        |) in
                      M.alloc (| Value.StructTuple "core::option::Option::None" [] |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "revm_interpreter::interpreter_action::call_inputs::CallValue::Apparent",
                          0
                        |) in
                      let apparent := M.copy (| γ0_0 |) in
                      M.alloc (|
                        Value.StructTuple "core::option::Option::Some" [ M.read (| apparent |) ]
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_apparent : M.IsAssociatedFunction Self "apparent" apparent.
      
      (*
          pub const fn is_apparent(&self) -> bool {
              matches!(self, Self::Apparent(_))
          }
      *)
      Definition is_apparent (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.read (|
              M.match_operator (|
                self,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "revm_interpreter::interpreter_action::call_inputs::CallValue::Apparent",
                          0
                        |) in
                      M.alloc (| Value.Bool true |)));
                  fun γ => ltac:(M.monadic (M.alloc (| Value.Bool false |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_apparent : M.IsAssociatedFunction Self "is_apparent" is_apparent.
    End Impl_revm_interpreter_interpreter_action_call_inputs_CallValue.
  End call_inputs.
End interpreter_action.
