diff --git a/src/Nethermind/Nethermind.Evm.Test/Tracing/DebugTracerTests.cs b/src/Nethermind/Nethermind.Evm.Test/Tracing/DebugTracerTests.cs
index c4bfadd34fa..ba71b881ae1 100644
--- a/src/Nethermind/Nethermind.Evm.Test/Tracing/DebugTracerTests.cs
+++ b/src/Nethermind/Nethermind.Evm.Test/Tracing/DebugTracerTests.cs
@@ -303,7 +303,8 @@ public void Debugger_Can_Alter_Data_Stack(string bytecodeHex)
             {
                 // we pop the condition and overwrite it with a false to force breaking out of the loop
                 EvmStack stack = new(tracer.CurrentState.DataStackHead, tracer, tracer.CurrentState.DataStack);
-                if (!stack.PopLimbo()) throw new EvmStackUnderflowException();
+                if (stack.Head == 0) throw new EvmStackUnderflowException();
+                stack.PopLimbo();
                 stack.PushByte<OffFlag>(0x00);
 
                 tracer.MoveNext();
diff --git a/src/Nethermind/Nethermind.Evm/EvmStack.cs b/src/Nethermind/Nethermind.Evm/EvmStack.cs
index 6f9aaa10940..c23776fc909 100644
--- a/src/Nethermind/Nethermind.Evm/EvmStack.cs
+++ b/src/Nethermind/Nethermind.Evm/EvmStack.cs
@@ -43,12 +43,8 @@ public EvmStack(scoped in int head, ITxTracer txTracer, scoped in Span<byte> byt
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ref byte PushBytesRef()
     {
-        // Workhorse method
         int head = Head;
-        if ((Head = head + 1) >= MaxStackSize)
-        {
-            ThrowEvmStackOverflowException();
-        }
+        Head = head + 1;
 
         return ref Unsafe.Add(ref MemoryMarshal.GetReference(_bytes), head * WordSize);
     }
@@ -70,7 +66,6 @@ public void PushBytes<TTracingInst>(scoped ReadOnlySpan<byte> value)
         if (value.Length != WordSize)
         {
             ref byte bytes = ref PushBytesRef();
-            // Not full entry, clear first
             Unsafe.As<byte, Word>(ref bytes) = default;
             value.CopyTo(MemoryMarshal.CreateSpan(ref Unsafe.Add(ref bytes, WordSize - value.Length), value.Length));
         }
@@ -197,6 +192,7 @@ public void Push20Bytes<TTracingInst>(ref byte value)
         ulong lane2 = Unsafe.As<byte, ulong>(ref Unsafe.Add(ref value, 4));
         ulong lane3 = Unsafe.As<byte, ulong>(ref Unsafe.Add(ref value, 12));
 
+        // Single 32-byte store
         head = Vector256.Create(default, lane1, lane2, lane3).AsByte();
     }
 
@@ -212,7 +208,6 @@ public void Push32Bytes<TTracingInst>(in Word value)
         if (TTracingInst.IsActive)
             _tracer.TraceWord(in value);
 
-        // Single 32-byte store
         PushedHead() = value;
     }
 
@@ -262,7 +257,7 @@ public void PushZero<TTracingInst>()
         if (TTracingInst.IsActive)
             _tracer.ReportStackPush(Bytes.ZeroByteSpan);
 
-        // Single 32-byte store: Zero 
+        // Single 32-byte store: Zero
         PushedHead() = default;
     }
 
@@ -302,7 +297,6 @@ public unsafe void PushUInt64<TTracingInst>(ulong value)
     /// <remarks>
     /// This method is a counterpart to <see cref="PopUInt256"/> and uses the same, raw data approach to write data back.
     /// </remarks>
-
     public void PushUInt256<TTracingInst>(in UInt256 value)
         where TTracingInst : struct, IFlag
     {
@@ -359,14 +353,9 @@ public void PushSignedInt256<TTracingInst>(in Int256.Int256 value)
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public bool PopLimbo()
+    public void PopLimbo()
     {
-        if (Head-- == 0)
-        {
-            return false;
-        }
-
-        return true;
+        Head--;
     }
 
     /// <summary>
@@ -377,11 +366,10 @@ public bool PopLimbo()
     /// All it does is <see cref="Unsafe.ReadUnaligned{T}(ref byte)"/> and then reverse endianness if needed. Then it creates <paramref name="result"/>.
     /// </remarks>
     /// <param name="result">The returned value.</param>
-    public bool PopUInt256(out UInt256 result)
+    public void PopUInt256(out UInt256 result)
     {
         Unsafe.SkipInit(out result);
         ref byte bytes = ref PopBytesByRef();
-        if (Unsafe.IsNullRef(ref bytes)) return false;
 
         if (Avx2.IsSupported)
         {
@@ -424,18 +412,11 @@ public bool PopUInt256(out UInt256 result)
 
             result = new UInt256(u0, u1, u2, u3);
         }
-
-        return true;
     }
 
     public readonly bool PeekUInt256IsZero()
     {
-        int head = Head;
-        if (head-- == 0)
-        {
-            return false;
-        }
-
+        int head = Head - 1;
         ref byte bytes = ref _bytes[head * WordSize];
         return Unsafe.ReadUnaligned<UInt256>(ref bytes).IsZero;
     }
@@ -443,87 +424,53 @@ public readonly bool PeekUInt256IsZero()
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public readonly ref byte PeekBytesByRef()
     {
-        int head = Head;
-        if (head-- == 0)
-        {
-            return ref Unsafe.NullRef<byte>();
-        }
+        int head = Head - 1;
         return ref Unsafe.Add(ref MemoryMarshal.GetReference(_bytes), head * WordSize);
     }
 
     public readonly Span<byte> PeekWord256()
     {
-        int head = Head;
-        if (head-- == 0)
-        {
-            ThrowEvmStackUnderflowException();
-        }
-
+        int head = Head - 1;
         return _bytes.Slice(head * WordSize, WordSize);
     }
 
-    public Address? PopAddress() => Head-- == 0 ? null : new Address(_bytes.Slice(Head * WordSize + WordSize - AddressSize, AddressSize).ToArray());
+    public Address? PopAddress()
+        => new Address(_bytes.Slice((--Head) * WordSize + WordSize - AddressSize, AddressSize).ToArray());
 
-    public bool PopAddress(out Address address)
+    public void PopAddress(out Address address)
     {
-        if (Head-- == 0)
-        {
-            address = null;
-            return false;
-        }
-
+        Head--;
         address = new Address(_bytes.Slice(Head * WordSize + WordSize - AddressSize, AddressSize).ToArray());
-        return true;
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ref byte PopBytesByRef()
     {
-        int head = Head;
-        if (head == 0)
-        {
-            return ref Unsafe.NullRef<byte>();
-        }
-        head--;
+        int head = Head - 1;
         Head = head;
         return ref Unsafe.Add(ref MemoryMarshal.GetReference(_bytes), head * WordSize);
     }
 
     public Span<byte> PopWord256()
-    {
-        ref byte bytes = ref PopBytesByRef();
-        if (Unsafe.IsNullRef(ref bytes)) ThrowEvmStackUnderflowException();
-
-        return MemoryMarshal.CreateSpan(ref bytes, WordSize);
-    }
+        => MemoryMarshal.CreateSpan(ref PopBytesByRef(), WordSize);
 
-    public bool PopWord256(out Span<byte> word)
+    public void PopWord256(out Span<byte> word)
     {
-        if (Head-- == 0)
-        {
-            word = default;
-            return false;
-        }
-
+        Head--;
         word = _bytes.Slice(Head * WordSize, WordSize);
-        return true;
     }
 
     public byte PopByte()
     {
         ref byte bytes = ref PopBytesByRef();
-
-        if (Unsafe.IsNullRef(ref bytes)) ThrowEvmStackUnderflowException();
-
         return Unsafe.Add(ref bytes, WordSize - sizeof(byte));
     }
 
     [SkipLocalsInit]
-    public EvmExceptionType Dup<TTracingInst>(int depth)
+    public void Dup<TTracingInst>(int depth)
         where TTracingInst : struct, IFlag
     {
         int head = Head;
-        if (head < depth) goto StackUnderflow;
 
         ref byte bytes = ref MemoryMarshal.GetReference(_bytes);
 
@@ -534,27 +481,17 @@ public EvmExceptionType Dup<TTracingInst>(int depth)
 
         if (TTracingInst.IsActive) Trace(depth);
 
-        if (++head >= MaxStackSize) goto StackOverflow;
-
-        Head = head;
-
-        return EvmExceptionType.None;
-    // Jump forward to be unpredicted by the branch predictor.
-    StackUnderflow:
-        return EvmExceptionType.StackUnderflow;
-    StackOverflow:
-        return EvmExceptionType.StackOverflow;
+        Head = head + 1;
     }
 
     public readonly bool EnsureDepth(int depth)
         => Head >= depth;
 
     [SkipLocalsInit]
-    public readonly EvmExceptionType Swap<TTracingInst>(int depth)
+    public readonly void Swap<TTracingInst>(int depth)
         where TTracingInst : struct, IFlag
     {
         int head = Head;
-        if (head < depth) goto StackUnderflow;
 
         ref byte bytes = ref MemoryMarshal.GetReference(_bytes);
 
@@ -566,18 +503,12 @@ public readonly EvmExceptionType Swap<TTracingInst>(int depth)
         Unsafe.WriteUnaligned(ref top, buffer);
 
         if (TTracingInst.IsActive) Trace(depth);
-
-        return EvmExceptionType.None;
-    // Jump forward to be unpredicted by the branch predictor.
-    StackUnderflow:
-        return EvmExceptionType.StackUnderflow;
     }
 
-    public readonly bool Exchange<TTracingInst>(int n, int m)
+    public readonly void Exchange<TTracingInst>(int n, int m)
         where TTracingInst : struct, IFlag
     {
         int maxDepth = Math.Max(n, m);
-        if (!EnsureDepth(maxDepth)) return false;
 
         ref byte bytes = ref MemoryMarshal.GetReference(_bytes);
 
@@ -589,8 +520,6 @@ public readonly bool Exchange<TTracingInst>(int n, int m)
         Unsafe.WriteUnaligned(ref second, buffer);
 
         if (TTracingInst.IsActive) Trace(maxDepth);
-
-        return true;
     }
 
     private readonly void Trace(int depth)
diff --git a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Bitwise.cs b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Bitwise.cs
index 7bffb4e634a..80e3fad7a7c 100644
--- a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Bitwise.cs
+++ b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Bitwise.cs
@@ -29,6 +29,11 @@ public interface IOpBitwise
         /// <param name="b">The second operand vector.</param>
         /// <returns>The result of the bitwise operation.</returns>
         static abstract Word Operation(in Word a, in Word b);
+
+        static virtual bool CheckStackUnderflow(ref EvmStack stack)
+        {
+            return stack.Head < 2;
+        }
     }
 
     /// <summary>
@@ -47,18 +52,19 @@ public static EvmExceptionType InstructionBitwise<TGasPolicy, TOpBitwise>(Virtua
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TOpBitwise : struct, IOpBitwise
     {
+        if (TOpBitwise.CheckStackUnderflow(ref stack))
+            goto StackUnderflow;
+
         // Deduct the operation's gas cost.
         TGasPolicy.Consume(ref gas, TOpBitwise.GasCost);
 
         // Pop the first operand from the stack by reference to minimize copying.
         ref byte bytesRef = ref stack.PopBytesByRef();
-        if (IsNullRef(ref bytesRef)) goto StackUnderflow;
         // Read the 256-bit vector from unaligned memory.
         Word aVec = ReadUnaligned<Word>(ref bytesRef);
 
         // Peek at the top of the stack for the second operand without removing it.
         bytesRef = ref stack.PeekBytesByRef();
-        if (IsNullRef(ref bytesRef)) goto StackUnderflow;
         Word bVec = ReadUnaligned<Word>(ref bytesRef);
 
         // Write the result directly into the memory of the top stack element.
diff --git a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Call.cs b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Call.cs
index e802d92416f..afd2ce56899 100644
--- a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Call.cs
+++ b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Call.cs
@@ -31,6 +31,11 @@ public interface IOpCall
         /// Returns the specific execution type of the call.
         /// </summary>
         abstract static ExecutionType ExecutionType { get; }
+
+        /// <summary>
+        /// Checks the stack for underflow conditions specific to call operations.
+        /// </summary>
+        abstract static bool CheckStackUnderflow(ref EvmStack stack);
     }
 
     /// <summary>
@@ -39,6 +44,11 @@ public interface IOpCall
     public struct OpCall : IOpCall
     {
         public static ExecutionType ExecutionType => ExecutionType.CALL;
+
+        public static bool CheckStackUnderflow(ref EvmStack stack)
+        {
+            return stack.Head < 7;
+        }
     }
 
     /// <summary>
@@ -47,6 +57,11 @@ public struct OpCall : IOpCall
     public struct OpCallCode : IOpCall
     {
         public static ExecutionType ExecutionType => ExecutionType.CALLCODE;
+
+        public static bool CheckStackUnderflow(ref EvmStack stack)
+        {
+            return stack.Head < 7;
+        }
     }
 
     /// <summary>
@@ -55,6 +70,11 @@ public struct OpCallCode : IOpCall
     public struct OpDelegateCall : IOpCall
     {
         public static ExecutionType ExecutionType => ExecutionType.DELEGATECALL;
+
+        public static bool CheckStackUnderflow(ref EvmStack stack)
+        {
+            return stack.Head < 6;
+        }
     }
 
     /// <summary>
@@ -64,6 +84,11 @@ public struct OpStaticCall : IOpCall
     {
         public static bool IsStatic => true;
         public static ExecutionType ExecutionType => ExecutionType.STATICCALL;
+
+        public static bool CheckStackUnderflow(ref EvmStack stack)
+        {
+            return stack.Head < 6;
+        }
     }
 
     /// <summary>
@@ -103,11 +128,15 @@ public static EvmExceptionType InstructionCall<TGasPolicy, TOpCall, TTracingInst
         // Clear previous return data.
         vm.ReturnData = null;
 
+        if (TOpCall.CheckStackUnderflow(ref stack))
+        {
+            goto StackUnderflow;
+        }
+
         // Pop the gas limit for the call.
-        if (!stack.PopUInt256(out UInt256 gasLimit)) goto StackUnderflow;
+        stack.PopUInt256(out UInt256 gasLimit);
         // Pop the code source address from the stack.
         Address codeSource = stack.PopAddress();
-        if (codeSource is null) goto StackUnderflow;
 
         ExecutionEnvironment env = vm.VmState.Env;
         // Determine the call value based on the call type.
@@ -122,17 +151,13 @@ public static EvmExceptionType InstructionCall<TGasPolicy, TOpCall, TTracingInst
             // Delegate calls use the value from the current execution context.
             callValue = env.Value;
         }
-        else if (!stack.PopUInt256(out callValue))
-        {
-            goto StackUnderflow;
-        }
+        else stack.PopUInt256(out callValue);
 
         // Pop additional parameters: data offset, data length, output offset, and output length.
-        if (!stack.PopUInt256(out UInt256 dataOffset) ||
-            !stack.PopUInt256(out UInt256 dataLength) ||
-            !stack.PopUInt256(out UInt256 outputOffset) ||
-            !stack.PopUInt256(out UInt256 outputLength))
-            goto StackUnderflow;
+        stack.PopUInt256(out UInt256 dataOffset);
+        stack.PopUInt256(out UInt256 dataLength);
+        stack.PopUInt256(out UInt256 outputOffset);
+        stack.PopUInt256(out UInt256 outputLength);
 
         // Charge gas for accessing the account's code (including delegation logic if applicable).
         bool _ = vm.TxExecutionContext.CodeInfoRepository
@@ -347,10 +372,14 @@ public static EvmExceptionType InstructionReturn<TGasPolicy>(VirtualMachine<TGas
             goto BadInstruction;
         }
 
-        // Pop memory position and length for the return data.
-        if (!stack.PopUInt256(out UInt256 position) ||
-            !stack.PopUInt256(out UInt256 length))
+        if (CheckStackUnderflow(ref stack, 2))
+        {
             goto StackUnderflow;
+        }
+
+        // Pop memory position and length for the return data.
+        stack.PopUInt256(out UInt256 position);
+        stack.PopUInt256(out UInt256 length);
 
         // Update the memory cost for the region being returned.
         if (!TGasPolicy.UpdateMemoryCost(ref gas, in position, in length, vm.VmState) ||
diff --git a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.CodeCopy.cs b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.CodeCopy.cs
index 658511bca8c..0ec44ca54a4 100644
--- a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.CodeCopy.cs
+++ b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.CodeCopy.cs
@@ -29,6 +29,15 @@ public interface IOpCodeCopy<TGasPolicy>
         /// <param name="vm">The virtual machine instance providing execution context.</param>
         /// <returns>A read-only span of bytes containing the code.</returns>
         abstract static ReadOnlySpan<byte> GetCode(VirtualMachine<TGasPolicy> vm);
+
+
+        /// <summary>
+        /// Checks the stack for underflow conditions specific to call operations.
+        /// </summary>
+        virtual static bool CheckStackUnderflow(ref EvmStack stack)
+        {
+            return stack.Head < 3;
+        }
     }
 
     /// <summary>
@@ -60,11 +69,12 @@ public static EvmExceptionType InstructionCodeCopy<TGasPolicy, TOpCodeCopy, TTra
         where TOpCodeCopy : struct, IOpCodeCopy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (TOpCodeCopy.CheckStackUnderflow(ref stack)) goto StackUnderflow;
+
         // Pop destination offset, source offset, and copy length.
-        if (!stack.PopUInt256(out UInt256 a) ||
-            !stack.PopUInt256(out UInt256 b) ||
-            !stack.PopUInt256(out UInt256 result))
-            goto StackUnderflow;
+        stack.PopUInt256(out UInt256 a);
+        stack.PopUInt256(out UInt256 b);
+        stack.PopUInt256(out UInt256 result);
 
         // Deduct gas for the operation plus the cost for memory expansion.
         // Gas cost is calculated as a fixed "VeryLow" cost plus a per-32-bytes cost.
@@ -143,14 +153,15 @@ public static EvmExceptionType InstructionExtCodeCopy<TGasPolicy, TTracingInst>(
         where TTracingInst : struct, IFlag
     {
         IReleaseSpec spec = vm.Spec;
+
+        if (CheckStackUnderflow(ref stack, 4)) goto StackUnderflow;
+
         // Retrieve the target account address.
         Address address = stack.PopAddress();
         // Pop destination offset, source offset, and length from the stack.
-        if (address is null ||
-            !stack.PopUInt256(out UInt256 a) ||
-            !stack.PopUInt256(out UInt256 b) ||
-            !stack.PopUInt256(out UInt256 result))
-            goto StackUnderflow;
+        stack.PopUInt256(out UInt256 a);
+        stack.PopUInt256(out UInt256 b);
+        stack.PopUInt256(out UInt256 result);
 
         // Deduct gas cost: cost for external code access plus memory expansion cost.
         TGasPolicy.ConsumeDataCopyGas(ref gas, isExternalCode: true, spec.GetExtCodeCost(), GasCostOf.Memory * EvmCalculations.Div32Ceiling(in result, out bool outOfGas));
@@ -229,13 +240,14 @@ public static EvmExceptionType InstructionExtCodeSize<TGasPolicy, TTracingInst>(
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackUnderflow(ref stack, 1)) goto StackUnderflow;
+
         IReleaseSpec spec = vm.Spec;
         // Deduct the gas cost for external code access.
         TGasPolicy.Consume(ref gas, spec.GetExtCodeCost());
 
         // Pop the account address from the stack.
         Address address = stack.PopAddress();
-        if (address is null) goto StackUnderflow;
 
         // Charge gas for accessing the account's state.
         if (!TGasPolicy.ConsumeAccountAccessGas(ref gas, spec, in vm.VmState.AccessTracker, vm.TxTracer.IsTracingAccess, address))
@@ -255,12 +267,19 @@ public static EvmExceptionType InstructionExtCodeSize<TGasPolicy, TTracingInst>(
             }
             // If the next instruction is GT or EQ and the top stack element is zero,
             // then this pattern likely corresponds to a contract existence check.
-            else if ((nextInstruction == Instruction.GT || nextInstruction == Instruction.EQ) &&
-                     stack.PeekUInt256IsZero())
+            else if ((nextInstruction == Instruction.GT || nextInstruction == Instruction.EQ))
             {
-                optimizeAccess = true;
-                // Remove the zero from the stack since we will have consumed it.
-                if (!stack.PopLimbo()) goto StackUnderflow;
+                if (CheckStackUnderflow(ref stack, 1))
+                {
+                    goto StackUnderflow;
+                }
+
+                if (stack.PeekUInt256IsZero())
+                {
+                    optimizeAccess = true;
+                    // Remove the zero from the stack since we will have consumed it.
+                    stack.PopLimbo();
+                }
             }
 
             if (optimizeAccess)
diff --git a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.ControlFlow.cs b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.ControlFlow.cs
index e8d9e1adbab..4ac7ab40b3c 100644
--- a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.ControlFlow.cs
+++ b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.ControlFlow.cs
@@ -31,6 +31,8 @@ public static EvmExceptionType InstructionProgramCounter<TGasPolicy, TTracingIns
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackOverflow(ref stack, 1)) return EvmExceptionType.StackOverflow;
+
         // Deduct the base gas cost for reading the program counter.
         TGasPolicy.Consume(ref gas, GasCostOf.Base);
         // The program counter pushed is adjusted by -1 to reflect the correct opcode location.
@@ -77,10 +79,13 @@ public static EvmExceptionType InstructionJumpDest<TGasPolicy>(VirtualMachine<TG
     public static EvmExceptionType InstructionJump<TGasPolicy>(VirtualMachine<TGasPolicy> vm, ref EvmStack stack, ref TGasPolicy gas, ref int programCounter)
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
     {
+
+        if (CheckStackUnderflow(ref stack, 1)) goto StackUnderflow;
+
         // Deduct the gas cost for performing a jump.
         TGasPolicy.Consume(ref gas, GasCostOf.Jump);
         // Pop the jump destination from the stack.
-        if (!stack.PopUInt256(out UInt256 result)) goto StackUnderflow;
+        stack.PopUInt256(out UInt256 result);
         // Validate the jump destination and update the program counter if valid.
         if (!Jump(result, ref programCounter, vm.VmState.Env)) goto InvalidJumpDestination;
 
@@ -110,13 +115,14 @@ public static EvmExceptionType InstructionJump<TGasPolicy>(VirtualMachine<TGasPo
     public static EvmExceptionType InstructionJumpIf<TGasPolicy>(VirtualMachine<TGasPolicy> vm, ref EvmStack stack, ref TGasPolicy gas, ref int programCounter)
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
     {
+        if (CheckStackUnderflow(ref stack, 2)) goto StackUnderflow;
+
         // Deduct the high gas cost for a conditional jump.
         TGasPolicy.Consume(ref gas, GasCostOf.JumpI);
         // Pop the jump destination.
-        if (!stack.PopUInt256(out UInt256 result)) goto StackUnderflow;
+        stack.PopUInt256(out UInt256 result);
 
-        bool shouldJump = TestJumpCondition(ref stack, out bool isOverflow);
-        if (isOverflow) goto StackUnderflow;
+        bool shouldJump = TestJumpCondition(ref stack);
         if (shouldJump)
         {
             if (!Jump(result, ref programCounter, vm.VmState.Env)) goto InvalidJumpDestination;
@@ -132,16 +138,10 @@ public static EvmExceptionType InstructionJumpIf<TGasPolicy>(VirtualMachine<TGas
 
     [SkipLocalsInit]
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static bool TestJumpCondition(ref EvmStack stack, out bool isOverflow)
+    private static bool TestJumpCondition(ref EvmStack stack)
     {
-        isOverflow = false;
         // Pop the condition as a byte reference.
         ref byte condition = ref stack.PopBytesByRef();
-        if (Unsafe.IsNullRef(in condition))
-        {
-            isOverflow = true;
-            return false;
-        }
         // If the condition is non-zero (i.e., true), attempt to perform the jump.
         return (Unsafe.As<byte, Vector256<byte>>(ref condition) != default);
     }
@@ -172,12 +172,11 @@ public static EvmExceptionType InstructionStop<TGasPolicy>(VirtualMachine<TGasPo
     public static EvmExceptionType InstructionRevert<TGasPolicy>(VirtualMachine<TGasPolicy> vm, ref EvmStack stack, ref TGasPolicy gas, ref int programCounter)
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
     {
+        if (CheckStackUnderflow(ref stack, 2)) goto StackUnderflow;
+
         // Attempt to pop memory offset and length; if either fails, signal a stack underflow.
-        if (!stack.PopUInt256(out UInt256 position) ||
-            !stack.PopUInt256(out UInt256 length))
-        {
-            goto StackUnderflow;
-        }
+        stack.PopUInt256(out UInt256 position);
+        stack.PopUInt256(out UInt256 length);
 
         // Ensure sufficient gas for any required memory expansion.
         if (!TGasPolicy.UpdateMemoryCost(ref gas, in position, in length, vm.VmState) ||
@@ -208,6 +207,8 @@ private static EvmExceptionType InstructionSelfDestruct<TGasPolicy>(VirtualMachi
         // Increment metrics for self-destruct operations.
         Metrics.IncrementSelfDestructs();
 
+        if (CheckStackUnderflow(ref stack, 1)) goto StackUnderflow;
+
         VmState<TGasPolicy> vmState = vm.VmState;
         IReleaseSpec spec = vm.Spec;
         IWorldState state = vm.WorldState;
@@ -224,8 +225,6 @@ private static EvmExceptionType InstructionSelfDestruct<TGasPolicy>(VirtualMachi
 
         // Pop the inheritor address from the stack; signal underflow if missing.
         Address inheritor = stack.PopAddress();
-        if (inheritor is null)
-            goto StackUnderflow;
 
         // Charge gas for account access; if insufficient, signal out-of-gas.
         if (!TGasPolicy.ConsumeAccountAccessGas(ref gas, spec, in vmState.AccessTracker, vm.TxTracer.IsTracingAccess, inheritor, false))
diff --git a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Create.cs b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Create.cs
index 66f79084b2c..f353578e86c 100644
--- a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Create.cs
+++ b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Create.cs
@@ -30,6 +30,11 @@ public interface IOpCreate
         /// Gets the execution type corresponding to the create operation.
         /// </summary>
         abstract static ExecutionType ExecutionType { get; }
+
+        /// <summary>
+        /// Checks the stack for underflow conditions specific to call operations.
+        /// </summary>
+        abstract static bool CheckStackUnderflow(ref EvmStack stack);
     }
 
     /// <summary>
@@ -41,6 +46,11 @@ public struct OpCreate : IOpCreate
         /// Gets the execution type for the CREATE opcode.
         /// </summary>
         public static ExecutionType ExecutionType => ExecutionType.CREATE;
+
+        public static bool CheckStackUnderflow(ref EvmStack stack)
+        {
+            return stack.Head < 3;
+        }
     }
 
     /// <summary>
@@ -52,6 +62,11 @@ public struct OpCreate2 : IOpCreate
         /// Gets the execution type for the CREATE2 opcode.
         /// </summary>
         public static ExecutionType ExecutionType => ExecutionType.CREATE2;
+
+        public static bool CheckStackUnderflow(ref EvmStack stack)
+        {
+            return stack.Head < 4;
+        }
     }
 
     /// <summary>
@@ -80,6 +95,9 @@ public static EvmExceptionType InstructionCreate<TGasPolicy, TOpCreate, TTracing
         // Increment metrics counter for contract creation operations.
         Metrics.IncrementCreates();
 
+        if (TOpCreate.CheckStackUnderflow(ref stack))
+            goto StackUnderflow;
+
         // Obtain the current EVM specification and check if the call is static (static calls cannot create contracts).
         IReleaseSpec spec = vm.Spec;
         if (vm.VmState.IsStatic)
@@ -92,10 +110,9 @@ public static EvmExceptionType InstructionCreate<TGasPolicy, TOpCreate, TTracing
 
         // Pop parameters off the stack: value to transfer, memory position for the initialization code,
         // and the length of the initialization code.
-        if (!stack.PopUInt256(out UInt256 value) ||
-            !stack.PopUInt256(out UInt256 memoryPositionOfInitCode) ||
-            !stack.PopUInt256(out UInt256 initCodeLength))
-            goto StackUnderflow;
+        stack.PopUInt256(out UInt256 value);
+        stack.PopUInt256(out UInt256 memoryPositionOfInitCode);
+        stack.PopUInt256(out UInt256 initCodeLength);
 
         Span<byte> salt = default;
         // For CREATE2, an extra salt value is required. Use type check to differentiate.
diff --git a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Crypto.cs b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Crypto.cs
index f0015a84489..b1de9caa0d5 100644
--- a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Crypto.cs
+++ b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Crypto.cs
@@ -23,9 +23,11 @@ public static EvmExceptionType InstructionKeccak256<TGasPolicy, TTracingInst>(Vi
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackUnderflow(ref stack, 2)) goto StackUnderflow;
+
         // Ensure two 256-bit words are available (memory offset and length).
-        if (!stack.PopUInt256(out UInt256 a) || !stack.PopUInt256(out UInt256 b))
-            goto StackUnderflow;
+        stack.PopUInt256(out UInt256 a);
+        stack.PopUInt256(out UInt256 b);
 
         // Deduct gas: base cost plus additional cost per 32-byte word.
         TGasPolicy.Consume(ref gas, GasCostOf.Sha3 + GasCostOf.Sha3Word * EvmCalculations.Div32Ceiling(in b, out bool outOfGas));
diff --git a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Environment.cs b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Environment.cs
index 7e770d5ec07..b727e983959 100644
--- a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Environment.cs
+++ b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Environment.cs
@@ -168,6 +168,8 @@ public static EvmExceptionType InstructionEnvAddress<TGasPolicy, TOpEnv, TTracin
         where TOpEnv : struct, IOpEnvAddress<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackOverflow(ref stack, 1)) return EvmExceptionType.StackOverflow;
+
         // Deduct the gas cost as defined by the operation implementation.
         TGasPolicy.Consume(ref gas, TOpEnv.GasCost);
 
@@ -197,6 +199,8 @@ public static EvmExceptionType InstructionBlkAddress<TGasPolicy, TOpEnv, TTracin
         where TOpEnv : struct, IOpBlkAddress<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackOverflow(ref stack, 1)) return EvmExceptionType.StackOverflow;
+
         // Deduct the gas cost as defined by the operation implementation.
         TGasPolicy.Consume(ref gas, TOpEnv.GasCost);
 
@@ -225,6 +229,8 @@ public static EvmExceptionType InstructionEnvUInt256<TGasPolicy, TOpEnv, TTracin
         where TOpEnv : struct, IOpEnvUInt256<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackOverflow(ref stack, 1)) return EvmExceptionType.StackOverflow;
+
         TGasPolicy.Consume(ref gas, TOpEnv.GasCost);
 
         ref readonly UInt256 result = ref TOpEnv.Operation(vm.VmState);
@@ -250,6 +256,8 @@ public static EvmExceptionType InstructionBlkUInt256<TGasPolicy, TOpEnv, TTracin
         where TOpEnv : struct, IOpBlkUInt256<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackOverflow(ref stack, 1)) return EvmExceptionType.StackOverflow;
+
         TGasPolicy.Consume(ref gas, TOpEnv.GasCost);
 
         ref readonly UInt256 result = ref TOpEnv.Operation(vm);
@@ -275,6 +283,8 @@ public static EvmExceptionType InstructionEnvUInt32<TGasPolicy, TOpEnv, TTracing
         where TOpEnv : struct, IOpEnvUInt32<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackOverflow(ref stack, 1)) return EvmExceptionType.StackOverflow;
+
         TGasPolicy.Consume(ref gas, TOpEnv.GasCost);
 
         uint result = TOpEnv.Operation(vm.VmState);
@@ -300,6 +310,8 @@ public static EvmExceptionType InstructionEnvUInt64<TGasPolicy, TOpEnv, TTracing
         where TOpEnv : struct, IOpEnvUInt64<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackOverflow(ref stack, 1)) return EvmExceptionType.StackOverflow;
+
         TGasPolicy.Consume(ref gas, TOpEnv.GasCost);
 
         ulong result = TOpEnv.Operation(vm.VmState);
@@ -325,6 +337,8 @@ public static EvmExceptionType InstructionBlkUInt64<TGasPolicy, TOpEnv, TTracing
         where TOpEnv : struct, IOpBlkUInt64<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackOverflow(ref stack, 1)) return EvmExceptionType.StackOverflow;
+
         TGasPolicy.Consume(ref gas, TOpEnv.GasCost);
 
         ulong result = TOpEnv.Operation(vm);
@@ -350,6 +364,8 @@ public static EvmExceptionType InstructionEnv32Bytes<TGasPolicy, TOpEnv, TTracin
         where TOpEnv : struct, IOpEnv32Bytes<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackOverflow(ref stack, 1)) return EvmExceptionType.StackOverflow;
+
         TGasPolicy.Consume(ref gas, TOpEnv.GasCost);
 
         ref readonly ValueHash256 result = ref TOpEnv.Operation(vm);
@@ -450,6 +466,7 @@ public static EvmExceptionType InstructionBlobBaseFee<TGasPolicy, TTracingInst>(
         // If the blob base fee is missing (no ExcessBlobGas set), this opcode is invalid.
         if (!context.Header.ExcessBlobGas.HasValue) goto BadInstruction;
 
+        if (CheckStackOverflow(ref stack, 1)) return EvmExceptionType.StackOverflow;
         // Charge the base gas cost for this opcode.
         TGasPolicy.Consume(ref gas, GasCostOf.Base);
         stack.Push32Bytes<TTracingInst>(in context.BlobBaseFee);
@@ -549,12 +566,13 @@ public static EvmExceptionType InstructionBalance<TGasPolicy, TTracingInst>(Virt
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackUnderflow(ref stack, 1)) goto StackUnderflow;
+
         IReleaseSpec spec = vm.Spec;
         // Deduct gas cost for balance operation as per specification.
         TGasPolicy.Consume(ref gas, spec.GetBalanceCost());
 
         Address address = stack.PopAddress();
-        if (address is null) goto StackUnderflow;
 
         // Charge gas for account access. If insufficient gas remains, abort.
         if (!TGasPolicy.ConsumeAccountAccessGas(ref gas, spec, in vm.VmState.AccessTracker, vm.TxTracer.IsTracingAccess, address)) goto OutOfGas;
@@ -586,6 +604,8 @@ public static EvmExceptionType InstructionSelfBalance<TGasPolicy, TTracingInst>(
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackOverflow(ref stack, 1)) return EvmExceptionType.StackOverflow;
+
         TGasPolicy.Consume(ref gas, GasCostOf.SelfBalance);
 
         // Get balance for currently executing account.
@@ -614,11 +634,12 @@ public static EvmExceptionType InstructionExtCodeHash<TGasPolicy, TTracingInst>(
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackUnderflow(ref stack, 1)) goto StackUnderflow;
+
         IReleaseSpec spec = vm.Spec;
         TGasPolicy.Consume(ref gas, spec.GetExtCodeHashCost());
 
         Address address = stack.PopAddress();
-        if (address is null) goto StackUnderflow;
         // Check if enough gas for account access and charge accordingly.
         if (!TGasPolicy.ConsumeAccountAccessGas(ref gas, spec, in vm.VmState.AccessTracker, vm.TxTracer.IsTracingAccess, address)) goto OutOfGas;
 
@@ -663,10 +684,11 @@ public static EvmExceptionType InstructionExtCodeHashEof<TGasPolicy, TTracingIns
         where TTracingInst : struct, IFlag
     {
         IReleaseSpec spec = vm.Spec;
+        if (CheckStackUnderflow(ref stack, 1)) goto StackUnderflow;
+
         TGasPolicy.Consume(ref gas, spec.GetExtCodeHashCost());
 
         Address address = stack.PopAddress();
-        if (address is null) goto StackUnderflow;
         if (!TGasPolicy.ConsumeAccountAccessGas(ref gas, spec, in vm.VmState.AccessTracker, vm.TxTracer.IsTracingAccess, address)) goto OutOfGas;
 
         IWorldState state = vm.WorldState;
@@ -714,6 +736,8 @@ public static EvmExceptionType InstructionPrevRandao<TGasPolicy, TTracingInst>(V
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackOverflow(ref stack, 1)) return EvmExceptionType.StackOverflow;
+
         // Charge the base gas cost for this opcode.
         TGasPolicy.Consume(ref gas, GasCostOf.Base);
         stack.Push32Bytes<TTracingInst>(in vm.BlockExecutionContext.PrevRandao);
@@ -737,6 +761,7 @@ public static EvmExceptionType InstructionGas<TGasPolicy, TTracingInst>(VirtualM
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackOverflow(ref stack, 1)) return EvmExceptionType.StackOverflow;
         // Deduct the base gas cost for reading gas.
         TGasPolicy.Consume(ref gas, GasCostOf.Base);
 
@@ -771,11 +796,12 @@ public static EvmExceptionType InstructionBlobHash<TGasPolicy, TTracingInst>(Vir
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackUnderflow(ref stack, 1)) goto StackUnderflow;
         // Deduct the gas cost for blob hash operation.
         TGasPolicy.Consume(ref gas, GasCostOf.BlobHash);
 
         // Pop the blob index from the stack.
-        if (!stack.PopUInt256(out UInt256 result)) goto StackUnderflow;
+        stack.PopUInt256(out UInt256 result);
 
         // Retrieve the array of versioned blob hashes from the execution context.
         byte[][] versionedHashes = vm.TxExecutionContext.BlobVersionedHashes;
@@ -817,11 +843,12 @@ public static EvmExceptionType InstructionBlockHash<TGasPolicy, TTracingInst>(Vi
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackUnderflow(ref stack, 1)) goto StackUnderflow;
         // Deduct the gas cost for block hash operation.
         TGasPolicy.Consume(ref gas, GasCostOf.BlockHash);
 
         // Pop the block number from the stack.
-        if (!stack.PopUInt256(out UInt256 a)) goto StackUnderflow;
+        stack.PopUInt256(out UInt256 a);
 
         // Convert the block number to a long. Clamp the value to long.MaxValue if it exceeds it.
         long number = a > long.MaxValue ? long.MaxValue : (long)a.u0;
diff --git a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Eof.cs b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Eof.cs
index 3be4898dfb1..40822b5d53f 100644
--- a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Eof.cs
+++ b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Eof.cs
@@ -29,6 +29,7 @@ public interface IOpEofCall
         virtual static bool IsStatic => false;
         // Specifies the execution type of the call.
         abstract static ExecutionType ExecutionType { get; }
+        abstract static bool CheckStackUnderflow(ref EvmStack stack);
     }
 
     /// <summary>
@@ -37,6 +38,11 @@ public interface IOpEofCall
     public struct OpEofCall : IOpEofCall
     {
         public static ExecutionType ExecutionType => ExecutionType.EOFCALL;
+
+        public static bool CheckStackUnderflow(ref EvmStack stack)
+        {
+            return stack.Head < 4;
+        }
     }
 
     /// <summary>
@@ -45,6 +51,11 @@ public struct OpEofCall : IOpEofCall
     public struct OpEofDelegateCall : IOpEofCall
     {
         public static ExecutionType ExecutionType => ExecutionType.EOFDELEGATECALL;
+
+        public static bool CheckStackUnderflow(ref EvmStack stack)
+        {
+            return stack.Head < 3;
+        }
     }
 
     /// <summary>
@@ -54,6 +65,11 @@ public struct OpEofStaticCall : IOpEofCall
     {
         public static bool IsStatic => true;
         public static ExecutionType ExecutionType => ExecutionType.EOFSTATICCALL;
+
+        public static bool CheckStackUnderflow(ref EvmStack stack)
+        {
+            return stack.Head < 3;
+        }
     }
 
     /// <summary>
@@ -72,6 +88,8 @@ public static EvmExceptionType InstructionReturnDataSize<TGasPolicy, TTracingIns
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackOverflow(ref stack, 1)) return EvmExceptionType.StackOverflow;
+
         // Deduct base gas cost for this instruction.
         TGasPolicy.Consume(ref gas, GasCostOf.Base);
 
@@ -99,13 +117,11 @@ public static EvmExceptionType InstructionReturnDataCopy<TGasPolicy, TTracingIns
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackUnderflow(ref stack, 3)) goto StackUnderflow;
         // Pop the required parameters: destination memory offset, source offset in return data, and number of bytes to copy.
-        if (!stack.PopUInt256(out UInt256 destOffset) ||
-            !stack.PopUInt256(out UInt256 sourceOffset) ||
-            !stack.PopUInt256(out UInt256 size))
-        {
-            goto StackUnderflow;
-        }
+        stack.PopUInt256(out UInt256 destOffset);
+        stack.PopUInt256(out UInt256 sourceOffset);
+        stack.PopUInt256(out UInt256 size);
 
         // Deduct the fixed gas cost and the memory cost based on the size (rounded up to 32-byte words).
         TGasPolicy.Consume(ref gas, GasCostOf.VeryLow + GasCostOf.Memory * EvmCalculations.Div32Ceiling(in size, out bool outOfGas));
@@ -161,11 +177,13 @@ public static EvmExceptionType InstructionDataLoad<TGasPolicy, TTracingInst>(Vir
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+
         ICodeInfo codeInfo = vm.VmState.Env.CodeInfo;
         // Ensure the instruction is only valid for non-legacy (EOF) code.
         if (codeInfo.Version == 0)
             goto BadInstruction;
 
+        if (CheckStackUnderflow(ref stack, 1)) return EvmExceptionType.StackUnderflow;
         // Deduct gas required for data loading.
         if (!TGasPolicy.UpdateGas(ref gas, GasCostOf.DataLoad))
             goto OutOfGas;
@@ -193,10 +211,13 @@ public static EvmExceptionType InstructionDataLoadN<TGasPolicy, TTracingInst>(Vi
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+
         ICodeInfo codeInfo = vm.VmState.Env.CodeInfo;
         if (codeInfo.Version == 0)
             goto BadInstruction;
 
+        if (CheckStackOverflow(ref stack, 1)) return EvmExceptionType.StackOverflow;
+
         if (!TGasPolicy.UpdateGas(ref gas, GasCostOf.DataLoadN))
             goto OutOfGas;
 
@@ -255,13 +276,12 @@ public static EvmExceptionType InstructionDataCopy<TGasPolicy, TTracingInst>(Vir
         if (codeInfo.Version == 0)
             goto BadInstruction;
 
+        if (CheckStackUnderflow(ref stack, 3)) goto StackUnderflow;
+
         // Pop destination memory offset, data section offset, and size.
-        if (!stack.PopUInt256(out UInt256 memOffset) ||
-            !stack.PopUInt256(out UInt256 offset) ||
-            !stack.PopUInt256(out UInt256 size))
-        {
-            goto StackUnderflow;
-        }
+        stack.PopUInt256(out UInt256 memOffset);
+        stack.PopUInt256(out UInt256 offset);
+        stack.PopUInt256(out UInt256 size);
 
         // Calculate memory expansion gas cost and deduct overall gas for data copy.
         if (!TGasPolicy.UpdateGas(ref gas, GasCostOf.DataCopy + GasCostOf.Memory * EvmCalculations.Div32Ceiling(in size, out bool outOfGas))
@@ -539,12 +559,14 @@ public static EvmExceptionType InstructionDupN<TGasPolicy, TTracingInst>(Virtual
 
         // Read the immediate operand.
         int imm = codeInfo.CodeSection.Span[programCounter];
-        // Duplicate the (imm+1)th stack element.
-        EvmExceptionType result = stack.Dup<TTracingInst>(imm + 1);
 
+        if (CheckStackUnderflow(ref stack, imm + 1)) return EvmExceptionType.StackUnderflow;
+        if (CheckStackOverflow(ref stack, 1)) return EvmExceptionType.StackOverflow;
+        // Duplicate the (imm+1)th stack element.
+        stack.Dup<TTracingInst>(imm + 1);
         programCounter += 1;
 
-        return result;
+        return EvmExceptionType.None;
     // Jump forward to be unpredicted by the branch predictor.
     OutOfGas:
         return EvmExceptionType.OutOfGas;
@@ -570,11 +592,14 @@ public static EvmExceptionType InstructionSwapN<TGasPolicy, TTracingInst>(Virtua
 
         // Immediate operand determines the swap index.
         int n = 1 + (int)codeInfo.CodeSection.Span[programCounter];
-        EvmExceptionType result = stack.Swap<TTracingInst>(n + 1);
+
+        if (CheckStackUnderflow(ref stack, n + 1)) return EvmExceptionType.StackUnderflow;
+
+        stack.Swap<TTracingInst>(n + 1);
 
         programCounter += 1;
 
-        return result;
+        return EvmExceptionType.None;
     // Jump forward to be unpredicted by the branch predictor.
     OutOfGas:
         return EvmExceptionType.OutOfGas;
@@ -640,6 +665,8 @@ public static EvmExceptionType InstructionEofCreate<TGasPolicy, TTracingInst>(Vi
         if (vm.VmState.IsStatic)
             goto StaticCallViolation;
 
+        if (CheckStackUnderflow(ref stack, 4)) return EvmExceptionType.StackUnderflow;
+
         // Cast the current code info to EOF-specific container type.
         EofCodeInfo container = env.CodeInfo as EofCodeInfo;
         ExecutionType currentContext = ExecutionType.EOFCREATE;
@@ -653,13 +680,10 @@ public static EvmExceptionType InstructionEofCreate<TGasPolicy, TTracingInst>(Vi
         int initContainerIndex = codeSection[programCounter++];
 
         // 3. Pop contract creation parameters from the stack.
-        if (!stack.PopUInt256(out UInt256 value) ||
-            !stack.PopWord256(out Span<byte> salt) ||
-            !stack.PopUInt256(out UInt256 dataOffset) ||
-            !stack.PopUInt256(out UInt256 dataSize))
-        {
-            goto OutOfGas;
-        }
+        stack.PopUInt256(out UInt256 value);
+        stack.PopWord256(out Span<byte> salt);
+        stack.PopUInt256(out UInt256 dataOffset);
+        stack.PopUInt256(out UInt256 dataSize);
 
         // 4. Charge for memory expansion for the input data.
         if (!TGasPolicy.UpdateMemoryCost(ref gas, in dataOffset, dataSize, vm.VmState))
@@ -795,6 +819,8 @@ public static EvmExceptionType InstructionReturnCode<TGasPolicy>(VirtualMachine<
         if (!TGasPolicy.UpdateGas(ref gas, GasCostOf.ReturnCode))
             goto OutOfGas;
 
+        if (CheckStackUnderflow(ref stack, 2)) return EvmExceptionType.StackUnderflow;
+
         IReleaseSpec spec = vm.Spec;
         EofCodeInfo codeInfo = (EofCodeInfo)vm.VmState.Env.CodeInfo;
 
@@ -847,10 +873,11 @@ public static EvmExceptionType InstructionReturnDataLoad<TGasPolicy, TTracingIns
         if (!spec.IsEofEnabled || codeInfo.Version == 0)
             goto BadInstruction;
 
+        if (CheckStackUnderflow(ref stack, 1)) goto StackUnderflow;
+
         TGasPolicy.Consume(ref gas, GasCostOf.VeryLow);
 
-        if (!stack.PopUInt256(out UInt256 offset))
-            goto StackUnderflow;
+        stack.PopUInt256(out UInt256 offset);
 
         ZeroPaddedSpan slice = vm.ReturnDataBuffer.Span.SliceWithZeroPadding(offset, 32);
         stack.PushBytes<TTracingInst>(slice);
@@ -893,13 +920,13 @@ public static EvmExceptionType InstructionEofCall<TGasPolicy, TOpEofCall, TTraci
         if (env.CodeInfo.Version == 0)
             goto BadInstruction;
 
-        // 1. Pop the target address (as 32 bytes) and memory offsets/length for the call data.
-        if (!stack.PopWord256(out Span<byte> targetBytes) ||
-            !stack.PopUInt256(out UInt256 dataOffset) ||
-            !stack.PopUInt256(out UInt256 dataLength))
-        {
+        if (TOpEofCall.CheckStackUnderflow(ref stack))
             goto StackUnderflow;
-        }
+
+        // 1. Pop the target address (as 32 bytes) and memory offsets/length for the call data.
+        stack.PopWord256(out Span<byte> targetBytes);
+        stack.PopUInt256(out UInt256 dataOffset);
+        stack.PopUInt256(out UInt256 dataLength);
 
         UInt256 transferValue;
         UInt256 callValue;
@@ -914,13 +941,10 @@ public static EvmExceptionType InstructionEofCall<TGasPolicy, TOpEofCall, TTraci
             transferValue = UInt256.Zero;
             callValue = env.Value;
         }
-        else if (stack.PopUInt256(out transferValue))
-        {
-            callValue = transferValue;
-        }
         else
         {
-            goto StackUnderflow;
+            stack.PopUInt256(out transferValue);
+            callValue = transferValue;
         }
 
         // 3. For non-static calls, ensure that a non-zero transfer value is not used in a static context.
diff --git a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Math1Param.cs b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Math1Param.cs
index 65c2c6f2815..2e9b9689092 100644
--- a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Math1Param.cs
+++ b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Math1Param.cs
@@ -34,6 +34,11 @@ public interface IOpMath1Param
         /// <param name="value">The input 256‐bit vector.</param>
         /// <returns>The result of the operation as a 256‐bit vector.</returns>
         abstract static Word Operation(Word value);
+
+        virtual static bool CheckStackUnderflow(ref EvmStack stack)
+        {
+            return stack.Head < 1;
+        }
     }
 
     /// <summary>
@@ -56,6 +61,9 @@ public static EvmExceptionType InstructionMath1Param<TGasPolicy, TOpMath>(Virtua
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TOpMath : struct, IOpMath1Param
     {
+        if (TOpMath.CheckStackUnderflow(ref stack))
+            goto StackUnderflow;
+
         // Deduct the gas cost associated with the math operation.
         TGasPolicy.Consume(ref gas, TOpMath.GasCost);
 
@@ -117,11 +125,13 @@ public static EvmExceptionType InstructionByte<TGasPolicy, TTracingInst>(Virtual
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackUnderflow(ref stack, 2))
+            goto StackUnderflow;
+
         TGasPolicy.Consume(ref gas, GasCostOf.VeryLow);
 
         // Pop the byte position and the 256-bit word.
-        if (!stack.PopUInt256(out UInt256 a))
-            goto StackUnderflow;
+        stack.PopUInt256(out UInt256 a);
         Span<byte> bytes = stack.PopWord256();
 
         // If the position is out-of-range, push zero.
@@ -157,16 +167,15 @@ public static EvmExceptionType InstructionByte<TGasPolicy, TTracingInst>(Virtual
     public static EvmExceptionType InstructionSignExtend<TGasPolicy>(VirtualMachine<TGasPolicy> vm, ref EvmStack stack, ref TGasPolicy gas, ref int programCounter)
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
     {
+        if (CheckStackUnderflow(ref stack, 2))
+            goto StackUnderflow;
+
         TGasPolicy.Consume(ref gas, GasCostOf.Low);
 
         // Pop the index to determine which byte to use for sign extension.
-        if (!stack.PopUInt256(out UInt256 a))
-            goto StackUnderflow;
+        stack.PopUInt256(out UInt256 a);
         if (a >= BigInt32)
         {
-            // If the index is out-of-range, no extension is needed.
-            if (!stack.EnsureDepth(1))
-                goto StackUnderflow;
             return EvmExceptionType.None;
         }
 
diff --git a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Math2Param.cs b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Math2Param.cs
index 28c59de7791..426b2faf1e2 100644
--- a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Math2Param.cs
+++ b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Math2Param.cs
@@ -31,6 +31,14 @@ public interface IOpMath2Param
         /// <param name="b">The second operand.</param>
         /// <param name="result">The result of the operation.</param>
         abstract static void Operation(in UInt256 a, in UInt256 b, out UInt256 result);
+
+        /// <summary>
+        /// Checks the stack for underflow conditions specific to call operations.
+        /// </summary>
+        virtual static bool CheckStackUnderflow(ref EvmStack stack)
+        {
+            return stack.Head < 2;
+        }
     }
 
     /// <summary>
@@ -54,11 +62,17 @@ public static EvmExceptionType InstructionMath2Param<TGasPolicy, TOpMath, TTraci
         where TOpMath : struct, IOpMath2Param
         where TTracingInst : struct, IFlag
     {
+        if (TOpMath.CheckStackUnderflow(ref stack))
+        {
+            goto StackUnderflow;
+        }
+
         // Deduct the gas cost for the specific math operation.
         TGasPolicy.Consume(ref gas, TOpMath.GasCost);
 
         // Pop two operands from the stack. If either pop fails, jump to the underflow handler.
-        if (!stack.PopUInt256(out UInt256 a) || !stack.PopUInt256(out UInt256 b)) goto StackUnderflow;
+        stack.PopUInt256(out UInt256 a);
+        stack.PopUInt256(out UInt256 b);
 
         // Execute the math operation defined by TOpMath.
         TOpMath.Operation(in a, in b, out UInt256 result);
@@ -275,16 +289,18 @@ public static EvmExceptionType InstructionExp<TGasPolicy, TTracingInst>(VirtualM
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
-        // Charge the fixed gas cost for exponentiation.
-        TGasPolicy.Consume(ref gas, GasCostOf.Exp);
-
-        // Pop the base value and exponent from the stack.
-        if (!stack.PopUInt256(out UInt256 a) ||
-            !stack.PopUInt256(out UInt256 exponent))
+        if (CheckStackUnderflow(ref stack, 2))
         {
             goto StackUnderflow;
         }
 
+        // Charge the fixed gas cost for exponentiation.
+        TGasPolicy.Consume(ref gas, GasCostOf.Exp);
+
+        // Pop the base value from the stack.
+        stack.PopUInt256(out UInt256 a);
+        stack.PopUInt256(out UInt256 exponent);
+
         // Determine the effective byte-length of the exponent.
         int leadingZeros = exponent.CountLeadingZeros() >> 3;
         if (leadingZeros == 32)
diff --git a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Math3Param.cs b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Math3Param.cs
index f9600b8dde3..c86363e539b 100644
--- a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Math3Param.cs
+++ b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Math3Param.cs
@@ -15,6 +15,10 @@ public interface IOpMath3Param
     {
         virtual static long GasCost => GasCostOf.Mid;
         abstract static void Operation(in UInt256 a, in UInt256 b, in UInt256 c, out UInt256 result);
+        virtual static bool CheckStackUnderflow(ref EvmStack stack)
+        {
+            return stack.Head < 3;
+        }
     }
 
     [SkipLocalsInit]
@@ -23,9 +27,16 @@ public static EvmExceptionType InstructionMath3Param<TGasPolicy, TOpMath, TTraci
         where TOpMath : struct, IOpMath3Param
         where TTracingInst : struct, IFlag
     {
+        if (TOpMath.CheckStackUnderflow(ref stack))
+        {
+            goto StackUnderflow;
+        }
+
         TGasPolicy.Consume(ref gas, TOpMath.GasCost);
 
-        if (!stack.PopUInt256(out UInt256 a) || !stack.PopUInt256(out UInt256 b) || !stack.PopUInt256(out UInt256 c)) goto StackUnderflow;
+        stack.PopUInt256(out UInt256 a);
+        stack.PopUInt256(out UInt256 b);
+        stack.PopUInt256(out UInt256 c);
 
         if (c.IsZero)
         {
diff --git a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Shifts.cs b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Shifts.cs
index c53d6bc1981..0e56ca91f8a 100644
--- a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Shifts.cs
+++ b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Shifts.cs
@@ -32,6 +32,14 @@ public interface IOpShift
         /// <param name="b">The value to be shifted.</param>
         /// <param name="result">The resulting shifted value.</param>
         abstract static void Operation(in UInt256 a, in UInt256 b, out UInt256 result);
+
+        /// <summary>
+        /// Checks the stack for underflow conditions specific to call operations.
+        /// </summary>
+        virtual static bool CheckStackUnderflow(ref EvmStack stack)
+        {
+            return stack.Head < 2;
+        }
     }
 
     /// <summary>
@@ -55,23 +63,25 @@ public static EvmExceptionType InstructionShift<TGasPolicy, TOpShift, TTracingIn
         where TOpShift : struct, IOpShift
         where TTracingInst : struct, IFlag
     {
+        if (TOpShift.CheckStackUnderflow(ref stack)) goto StackUnderflow;
+
         // Deduct gas cost specific to the shift operation.
         TGasPolicy.Consume(ref gas, TOpShift.GasCost);
 
         // Pop the shift amount from the stack.
-        if (!stack.PopUInt256(out UInt256 a)) goto StackUnderflow;
+        stack.PopUInt256(out UInt256 a);
 
         // If the shift amount is 256 or more, per EVM semantics, discard the second operand and push zero.
         if (a >= 256)
         {
             // Pop the second operand without using its value.
-            if (!stack.PopLimbo()) goto StackUnderflow;
+            stack.PopLimbo();
             stack.PushZero<TTracingInst>();
         }
         else
         {
             // Otherwise, pop the value to be shifted.
-            if (!stack.PopUInt256(out UInt256 b)) goto StackUnderflow;
+            stack.PopUInt256(out UInt256 b);
             // Perform the shift operation using the specific implementation.
             TOpShift.Operation(in a, in b, out UInt256 result);
             stack.PushUInt256<TTracingInst>(in result);
@@ -102,11 +112,19 @@ public static EvmExceptionType InstructionSar<TGasPolicy, TTracingInst>(VirtualM
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        static bool CheckStackUnderflow(ref EvmStack stack) => stack.Head < 2;
+
+        if (CheckStackUnderflow(ref stack))
+        {
+            goto StackUnderflow;
+        }
+
         // Deduct the gas cost for the arithmetic shift operation.
         TGasPolicy.Consume(ref gas, GasCostOf.VeryLow);
 
         // Pop the shift amount and the value to be shifted.
-        if (!stack.PopUInt256(out UInt256 a) || !stack.PopUInt256(out UInt256 b)) goto StackUnderflow;
+        stack.PopUInt256(out UInt256 a);
+        stack.PopUInt256(out UInt256 b);
 
         // If the shift amount is 256 or more, the result depends solely on the sign of the value.
         if (a >= 256)
diff --git a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Stack.cs b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Stack.cs
index ebe50e55f70..2018ec4eb41 100644
--- a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Stack.cs
+++ b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Stack.cs
@@ -18,6 +18,21 @@ namespace Nethermind.Evm;
 
 internal static partial class EvmInstructions
 {
+    const int PopStackRequiredItemsCount = 1;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool CheckStackUnderflow(ref EvmStack stack, int itemsPoppedCount)
+    {
+        return stack.Head < itemsPoppedCount;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool CheckStackOverflow(ref EvmStack stack, int itemsPushedCount)
+    {
+        return stack.Head + itemsPushedCount >= EvmStack.MaxStackSize;
+    }
+
+
     /// <summary>
     /// Pops a value from the EVM stack.
     /// Deducts the base gas cost and returns an exception if the stack is underflowed.
@@ -32,10 +47,15 @@ internal static partial class EvmInstructions
     public static EvmExceptionType InstructionPop<TGasPolicy>(VirtualMachine<TGasPolicy> vm, ref EvmStack stack, ref TGasPolicy gas, ref int programCounter)
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
     {
+        if (CheckStackUnderflow(ref stack, PopStackRequiredItemsCount))
+            return EvmExceptionType.StackUnderflow;
+
         // Deduct the minimal gas cost for a POP operation.
         TGasPolicy.Consume(ref gas, GasCostOf.Base);
         // Pop from the stack; if nothing to pop, signal a stack underflow.
-        return stack.PopLimbo() ? EvmExceptionType.None : EvmExceptionType.StackUnderflow;
+        stack.PopLimbo();
+
+        return EvmExceptionType.None;
     }
 
     /// <summary>
@@ -121,6 +141,12 @@ public static EvmExceptionType InstructionPush2<TGasPolicy, TTracingInst>(Virtua
         where TTracingInst : struct, IFlag
     {
         const int Size = sizeof(ushort);
+
+        if (CheckStackOverflow(ref stack, 1))
+        {
+            return EvmExceptionType.StackOverflow;
+        }
+
         // Deduct a very low gas cost for the push operation.
         TGasPolicy.Consume(ref gas, GasCostOf.VeryLow);
         // Retrieve the code segment containing immediate data.
@@ -150,9 +176,13 @@ public static EvmExceptionType InstructionPush2<TGasPolicy, TTracingInst>(Virtua
             else
             {
                 TGasPolicy.Consume(ref gas, GasCostOf.JumpI);
+                if (CheckStackUnderflow(ref stack, 1))
+                {
+                    goto StackUnderflow;
+                }
+
                 vm.OpCodeCount++;
-                bool shouldJump = TestJumpCondition(ref stack, out bool isOverflow);
-                if (isOverflow) goto StackUnderflow;
+                bool shouldJump = TestJumpCondition(ref stack);
                 if (!shouldJump)
                 {
                     // Move forward by 2 bytes + JUMPI
@@ -493,6 +523,12 @@ public static EvmExceptionType InstructionPush0<TGasPolicy, TTracingInst>(Virtua
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+
+        if (CheckStackOverflow(ref stack, 1))
+        {
+            return EvmExceptionType.StackOverflow;
+        }
+
         TGasPolicy.Consume(ref gas, GasCostOf.Base);
         stack.PushZero<TTracingInst>();
         return EvmExceptionType.None;
@@ -516,6 +552,11 @@ public static EvmExceptionType InstructionPush<TGasPolicy, TOpCount, TTracingIns
         where TOpCount : struct, IOpCount
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackOverflow(ref stack, 1))
+        {
+            return EvmExceptionType.StackOverflow;
+        }
+
         // Deduct a very low gas cost for the push operation.
         TGasPolicy.Consume(ref gas, GasCostOf.VeryLow);
         // Retrieve the code segment containing immediate data.
@@ -544,9 +585,17 @@ public static EvmExceptionType InstructionDup<TGasPolicy, TOpCount, TTracingInst
         where TOpCount : struct, IOpCount
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackUnderflow(ref stack, TOpCount.Count))
+            return EvmExceptionType.StackUnderflow;
+
+        if (CheckStackOverflow(ref stack, 1))
+            return EvmExceptionType.StackOverflow;
+
         TGasPolicy.Consume(ref gas, GasCostOf.VeryLow);
 
-        return stack.Dup<TTracingInst>(TOpCount.Count);
+        stack.Dup<TTracingInst>(TOpCount.Count);
+
+        return EvmExceptionType.None;
     }
 
     /// <summary>
@@ -566,9 +615,16 @@ public static EvmExceptionType InstructionSwap<TGasPolicy, TOpCount, TTracingIns
         where TOpCount : struct, IOpCount
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackUnderflow(ref stack, TOpCount.Count + 1))
+        {
+            return EvmExceptionType.StackUnderflow;
+        }
+
         TGasPolicy.Consume(ref gas, GasCostOf.VeryLow);
         // Swap the top element with the (n+1)th element; ensure adequate stack depth.
-        return stack.Swap<TTracingInst>(TOpCount.Count + 1);
+        stack.Swap<TTracingInst>(TOpCount.Count + 1);
+
+        return EvmExceptionType.None;
     }
 
     /// <summary>
@@ -595,8 +651,12 @@ public static EvmExceptionType InstructionLog<TGasPolicy, TOpCount>(VirtualMachi
         // Logging is not permitted in static call contexts.
         if (vmState.IsStatic) goto StaticCallViolation;
 
+        if (CheckStackUnderflow(ref stack, TOpCount.Count + 2))
+            goto StackUnderflow;
+
         // Pop memory offset and length for the log data.
-        if (!stack.PopUInt256(out UInt256 position) || !stack.PopUInt256(out UInt256 length)) goto StackUnderflow;
+        stack.PopUInt256(out UInt256 position);
+        stack.PopUInt256(out UInt256 length);
 
         // The number of topics is defined by the generic parameter.
         long topicsCount = TOpCount.Count;
diff --git a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Storage.cs b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Storage.cs
index 1cd5b0f56ec..3631bd03f62 100644
--- a/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Storage.cs
+++ b/src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.Storage.cs
@@ -18,6 +18,18 @@ namespace Nethermind.Evm;
 /// </summary>
 internal static partial class EvmInstructions
 {
+    const int TStoreStackRequiredItems = 2;
+    const int TLoadStackRequiredItems = 1;
+
+    const int SStoreStackRequiredItems = 2;
+    const int SLoadStackRequiredItems = 1;
+
+    const int MStoreStackRequiredItems = 2;
+    const int MStore8StackRequiredItems = 2;
+    const int MLoadStackRequiredItems = 1;
+    const int MCopyStackRequiredItems = 3;
+
+    const int CallDataLoadStackRequiredItems = 1;
 
     /// <summary>
     /// Executes the transient load (TLOAD) instruction.
@@ -36,14 +48,18 @@ public static EvmExceptionType InstructionTLoad<TGasPolicy, TTracingInst>(Virtua
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+
         // Increment the opcode metric for TLOAD.
         Metrics.TloadOpcode++;
 
+        if (CheckStackUnderflow(ref stack, TLoadStackRequiredItems))
+            goto StackUnderflow;
+
         // Deduct the fixed gas cost for TLOAD.
         TGasPolicy.Consume(ref gas, GasCostOf.TLoad);
 
         // Attempt to pop the key (offset) from the stack; if unavailable, signal a stack underflow.
-        if (!stack.PopUInt256(out UInt256 result)) goto StackUnderflow;
+        stack.PopUInt256(out UInt256 result);
 
         // Construct a transient storage cell using the executing account and the provided offset.
         StorageCell storageCell = new(vm.VmState.Env.ExecutingAccount, in result);
@@ -88,6 +104,9 @@ public static EvmExceptionType InstructionTStore<TGasPolicy>(VirtualMachine<TGas
         // Increment the opcode metric for TSTORE.
         Metrics.TstoreOpcode++;
 
+        if (CheckStackUnderflow(ref stack, TStoreStackRequiredItems))
+            goto StackUnderflow;
+
         VmState<TGasPolicy> vmState = vm.VmState;
 
         // Disallow storage modification during static calls.
@@ -97,7 +116,7 @@ public static EvmExceptionType InstructionTStore<TGasPolicy>(VirtualMachine<TGas
         TGasPolicy.Consume(ref gas, GasCostOf.TStore);
 
         // Pop the key (offset) from the stack; if unavailable, signal a stack underflow.
-        if (!stack.PopUInt256(out UInt256 result)) goto StackUnderflow;
+        stack.PopUInt256(out UInt256 result);
 
         // Construct a transient storage cell for the executing account at the specified key.
         StorageCell storageCell = new(vmState.Env.ExecutingAccount, in result);
@@ -144,10 +163,13 @@ public static EvmExceptionType InstructionMStore<TGasPolicy, TTracingInst>(Virtu
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackUnderflow(ref stack, MStoreStackRequiredItems))
+            goto StackUnderflow;
+
         TGasPolicy.Consume(ref gas, GasCostOf.VeryLow);
 
         // Pop the memory offset; if not available, signal a stack underflow.
-        if (!stack.PopUInt256(out UInt256 result)) goto StackUnderflow;
+        stack.PopUInt256(out UInt256 result);
 
         // Retrieve the 32-byte word to be stored.
         Span<byte> bytes = stack.PopWord256();
@@ -190,10 +212,13 @@ public static EvmExceptionType InstructionMStore8<TGasPolicy, TTracingInst>(Virt
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackUnderflow(ref stack, MStore8StackRequiredItems))
+            goto StackUnderflow;
+
         TGasPolicy.Consume(ref gas, GasCostOf.VeryLow);
 
         // Pop the memory offset from the stack; if missing, signal a stack underflow.
-        if (!stack.PopUInt256(out UInt256 result)) goto StackUnderflow;
+        stack.PopUInt256(out UInt256 result);
 
         // Pop a single byte from the stack.
         byte data = stack.PopByte();
@@ -237,10 +262,13 @@ public static EvmExceptionType InstructionMLoad<TGasPolicy, TTracingInst>(Virtua
         where TGasPolicy : struct, IGasPolicy<TGasPolicy>
         where TTracingInst : struct, IFlag
     {
+        if (CheckStackUnderflow(ref stack, MLoadStackRequiredItems))
+            goto StackUnderflow;
+
         TGasPolicy.Consume(ref gas, GasCostOf.VeryLow);
 
         // Pop the memory offset; if missing, signal a stack underflow.
-        if (!stack.PopUInt256(out UInt256 result)) goto StackUnderflow;
+        stack.PopUInt256(out UInt256 result);
 
         VmState<TGasPolicy> vmState = vm.VmState;
 
@@ -287,8 +315,13 @@ public static EvmExceptionType InstructionMCopy<TGasPolicy, TTracingInst>(Virtua
         // Increment the opcode metric for MCOPY.
         Metrics.MCopyOpcode++;
 
+        if (CheckStackUnderflow(ref stack, MCopyStackRequiredItems))
+            goto StackUnderflow;
+
         // Pop destination, source, and length values; if any are missing, signal a stack underflow.
-        if (!stack.PopUInt256(out UInt256 a) || !stack.PopUInt256(out UInt256 b) || !stack.PopUInt256(out UInt256 c)) goto StackUnderflow;
+        stack.PopUInt256(out UInt256 a);
+        stack.PopUInt256(out UInt256 b);
+        stack.PopUInt256(out UInt256 c);
 
         // Calculate additional gas cost based on the length (using a division rounding-up method) and deduct the total cost.
         TGasPolicy.Consume(ref gas, GasCostOf.VeryLow + GasCostOf.VeryLow * EvmCalculations.Div32Ceiling(c, out bool outOfGas));
@@ -344,6 +377,9 @@ internal static EvmExceptionType InstructionSStoreUnmetered<TGasPolicy, TTracing
         // Increment the SSTORE opcode metric.
         Metrics.IncrementSStoreOpcode();
 
+        if (CheckStackUnderflow(ref stack, SStoreStackRequiredItems))
+            goto StackUnderflow;
+
         VmState<TGasPolicy> vmState = vm.VmState;
         // Disallow storage modifications in static calls.
         if (vmState.IsStatic) goto StaticCallViolation;
@@ -355,7 +391,7 @@ internal static EvmExceptionType InstructionSStoreUnmetered<TGasPolicy, TTracing
             goto OutOfGas;
 
         // Pop the key and then the new value for storage; signal underflow if unavailable.
-        if (!stack.PopUInt256(out UInt256 result)) goto StackUnderflow;
+        stack.PopUInt256(out UInt256 result);
         ReadOnlySpan<byte> bytes = stack.PopWord256();
 
         // Determine if the new value is effectively zero and normalize non-zero values by stripping leading zeros.
@@ -447,6 +483,9 @@ internal static EvmExceptionType InstructionSStoreMetered<TGasPolicy, TTracingIn
         // Increment the SSTORE opcode metric.
         Metrics.IncrementSStoreOpcode();
 
+        if (CheckStackUnderflow(ref stack, SStoreStackRequiredItems))
+            goto StackUnderflow;
+
         VmState<TGasPolicy> vmState = vm.VmState;
         // Disallow storage modifications in static calls.
         if (vmState.IsStatic) goto StaticCallViolation;
@@ -463,7 +502,7 @@ internal static EvmExceptionType InstructionSStoreMetered<TGasPolicy, TTracingIn
         }
 
         // Pop the key and then the new value for storage; signal underflow if unavailable.
-        if (!stack.PopUInt256(out UInt256 result)) goto StackUnderflow;
+        stack.PopUInt256(out UInt256 result);
         ReadOnlySpan<byte> bytes = stack.PopWord256();
 
         // Determine if the new value is effectively zero and normalize non-zero values by stripping leading zeros.
@@ -617,11 +656,14 @@ internal static EvmExceptionType InstructionSLoad<TGasPolicy, TTracingInst>(Virt
         // Increment the SLOAD opcode metric.
         Metrics.IncrementSLoadOpcode();
 
+        if (CheckStackUnderflow(ref stack, SLoadStackRequiredItems))
+            goto StackUnderflow;
+
         // Deduct the gas cost for performing an SLOAD.
         TGasPolicy.Consume(ref gas, spec.GetSLoadCost());
 
         // Pop the key from the stack; if unavailable, signal a stack underflow.
-        if (!stack.PopUInt256(out UInt256 result)) goto StackUnderflow;
+        stack.PopUInt256(out UInt256 result);
 
         // Construct the storage cell for the executing account.
         Address executingAccount = vm.VmState.Env.ExecutingAccount;
@@ -661,9 +703,11 @@ public static EvmExceptionType InstructionCallDataLoad<TGasPolicy, TTracingInst>
     {
         TGasPolicy.Consume(ref gas, GasCostOf.VeryLow);
 
-        // Pop the offset from which to load call data.
-        if (!stack.PopUInt256(out UInt256 result))
+        if (CheckStackUnderflow(ref stack, CallDataLoadStackRequiredItems))
             goto StackUnderflow;
+
+        // Pop the offset from which to load call data.
+        stack.PopUInt256(out UInt256 result);
         // Load 32 bytes from input data, applying zero padding as needed.
         stack.PushBytes<TTracingInst>(vm.VmState.Env.InputData.SliceWithZeroPadding(result, 32));