public EvaluateResponse Evaluate(EvaluateArguments args)
        {
            if ((engine.State & HALT_OR_FAULT) != 0)
            {
                return(DebugAdapter.FailedEvaluation);
            }

            var(typeHint, index, variableName) = Helpers.ParseEvalExpression(args.Expression);

            if (variableName.StartsWith("$storage"))
            {
                return(engine.EvaluateStorageExpression(this, args));
            }

            Variable?GetVariable(StackItem item, Parameter local)
            {
                if (index.HasValue)
                {
                    if (item is Neo.VM.Types.Array neoArray &&
                        index.Value < neoArray.Count)
                    {
                        return(neoArray[index.Value].GetVariable(this, local.Name + $"[{index.Value}]", typeHint));
                    }
                }
                else
                {
                    return(item.GetVariable(this, local.Name, typeHint ?? local.Type));
                }

                return(null);
            }

            for (var stackIndex = 0; stackIndex < engine.InvocationStack.Count; stackIndex++)
            {
                var context = engine.InvocationStack.Peek(stackIndex);
                if (context.AltStack.Count <= 0)
                {
                    continue;
                }

                var method = Contract.GetMethod(context);
                if (method == null)
                {
                    continue;
                }

                var locals    = method.Locals.ToArray();
                var variables = (Neo.VM.Types.Array)context.AltStack.Peek(0);

                for (int varIndex = 0; varIndex < Math.Min(variables.Count, locals.Length); varIndex++)
                {
                    var local = locals[varIndex];
                    if (local.Name == variableName)
                    {
                        var variable = GetVariable(variables[varIndex], local);
                        if (variable != null)
                        {
                            return(new EvaluateResponse()
                            {
                                Result = variable.Value,
                                VariablesReference = variable.VariablesReference,
                                Type = variable.Type
                            });
                        }
                    }
                }
            }

            return(DebugAdapter.FailedEvaluation);
        }